Flow creation in Postman - Deep Dive

Overview - Flow creation

What is it?

Flow creation in Postman means building a sequence of steps that automate API requests and tests. It lets you connect multiple API calls so they run one after another, passing data between them. This helps test complex scenarios without doing each step manually. Think of it as creating a story where each chapter depends on the last.

Why it matters

Without flow creation, testing APIs would be slow and error-prone because you'd have to run each request by hand and copy data between them. Flow creation saves time and reduces mistakes by automating these steps. It also helps catch bugs that only appear when APIs interact in a sequence, making your software more reliable.

Where it fits

Before learning flow creation, you should understand basic API requests and how to write simple tests in Postman. After mastering flows, you can explore advanced automation like using Postman monitors, integrating with CI/CD pipelines, or writing complex scripts for dynamic data handling.

Mental Model

Core Idea

Flow creation is chaining API requests and tests so they run automatically in order, sharing data to simulate real-world interactions.

Think of it like...

It's like following a recipe where each step depends on the previous one: you can't bake the cake until you mix the ingredients, and you can't frost it until it's baked.

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ API Request │ -> │ API Request │ -> │ API Request │
│   Step 1    │    │   Step 2    │    │   Step 3    │
└─────────────┘    └─────────────┘    └─────────────┘
       │                  │                  │
       ▼                  ▼                  ▼
  Tests & Data       Tests & Data       Tests & Data
  Extraction        Extraction        Extraction

Build-Up - 7 Steps

1

Foundation

Understanding API Requests in Postman

Concept: Learn what an API request is and how to send one in Postman.

An API request asks a server for data or to perform an action. In Postman, you create a request by entering the URL, choosing the method (GET, POST, etc.), and adding headers or body data if needed. Then you click 'Send' to see the response.

Result

You get a response from the server showing data or confirmation of the action.

Knowing how to send a single API request is the base for building flows that combine many requests.

2

Foundation

Writing Basic Tests in Postman

Concept: Learn how to check if an API response is correct using tests.

Postman lets you write simple JavaScript tests that run after a request. For example, you can check if the status code is 200 or if the response contains certain data. These tests help confirm the API works as expected.

Result

Tests pass or fail, giving immediate feedback on the API's behavior.

Tests turn raw responses into meaningful checks, essential for automated flows.

3

Intermediate

Chaining Requests with Variables

🤔Before reading on: do you think you can use data from one request directly in the next without saving it? Commit to your answer.

Concept: Learn how to save data from one response and use it in the next request.

After a request runs, you can extract data from its response using JavaScript and save it as a variable in Postman. Then, in the next request, you use that variable in the URL, headers, or body. This links requests together, creating a flow.

Result

Requests run in order, each using data from the previous one, simulating real API interactions.

Understanding variable passing is key to making flows dynamic and realistic.

4

Intermediate

Using Postman Collections to Organize Flows

🤔Before reading on: do you think a collection is just a folder for requests or does it have more features? Commit to your answer.

Concept: Learn how to group requests into collections to run them as a flow.

A collection is a group of API requests saved together. You can run all requests in a collection in order using the Collection Runner. This lets you automate the flow instead of running requests one by one.

Result

You can execute multiple requests sequentially with one click, seeing combined test results.

Collections provide the structure needed to build and manage flows efficiently.

5

Intermediate

Controlling Flow with Pre-request and Test Scripts

🤔Before reading on: do you think scripts can only check responses or can they also change requests? Commit to your answer.

Concept: Learn how to use scripts to prepare requests and decide what happens next in the flow.

Pre-request scripts run before a request and can set variables or modify the request dynamically. Test scripts run after and can save data or stop the flow if tests fail. Together, they control the flow's logic and data.

Result

Flows become flexible and can handle different scenarios automatically.

Scripts turn static flows into smart, adaptable sequences.

6

Advanced

Automating Flows with Collection Runner and Environments

🤔Before reading on: do you think environments only store variables or do they affect flow execution? Commit to your answer.

Concept: Learn how to run flows repeatedly with different data sets using environments and the Collection Runner.

Environments hold sets of variables for different situations (like dev or prod). The Collection Runner lets you run a flow multiple times with different environment variables or data files. This automates testing across many cases.

Result

You can test APIs thoroughly and consistently without manual effort.

Combining environments and runners scales flow testing to real-world needs.

7

Expert

Handling Complex Flows with Conditional Logic and Error Handling

🤔Before reading on: do you think Postman flows can skip or repeat requests based on conditions? Commit to your answer.

Concept: Learn how to build flows that change behavior based on test results or data, including stopping or looping requests.

Using scripts, you can write conditions to skip requests if previous tests fail or to retry requests on errors. You can also chain requests dynamically by setting variables that control which requests run next. This makes flows robust and closer to real user scenarios.

Result

Flows handle unexpected situations gracefully and test complex API behaviors.

Mastering conditional logic in flows is essential for professional-grade API testing.

Under the Hood

Postman runs flows by executing requests in sequence within a collection. Each request can run pre-request scripts to prepare data, then send the HTTP request, then run test scripts to check responses and save variables. Variables are stored in different scopes (global, environment, collection, local) and passed between requests. The Collection Runner orchestrates this process, managing iteration over data sets and environments.

Why designed this way?

Postman was designed to simplify API testing by mimicking real-world API usage where calls depend on each other. Using scripts and variables allows flexibility without needing a full programming environment. Collections and runners provide a user-friendly way to automate tests without complex setup, balancing power and ease of use.

┌───────────────┐
│ Collection    │
│ (Flow)        │
└──────┬────────┘
       │
       ▼
┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Request 1     │──────▶│ Request 2     │──────▶│ Request 3     │
│ Pre-request   │       │ Pre-request   │       │ Pre-request   │
│ Send Request  │       │ Send Request  │       │ Send Request  │
│ Test Script   │       │ Test Script   │       │ Test Script   │
└───────────────┘       └───────────────┘       └───────────────┘
       │                      │                       │
       ▼                      ▼                       ▼
  Variables stored and passed between requests

Myth Busters - 4 Common Misconceptions

Quick: Do you think Postman automatically shares data between requests without scripting? Commit to yes or no.

Common Belief: Postman automatically passes data from one request to the next without any setup.

Reality: You must explicitly extract data from responses and save it as variables using scripts to share between requests.

Why it matters: Assuming automatic data sharing leads to broken flows and confusing test failures.

Quick: Do you think running requests in a collection always means they run in order? Commit to yes or no.

Common Belief: Requests in a Postman collection always run in the order they appear.

Reality: Requests run in order only when using the Collection Runner; manually clicking requests runs them independently.

Why it matters: Misunderstanding this causes tests to fail because dependencies between requests are not respected.

Quick: Do you think Postman flows can handle complex logic like loops and conditionals natively? Commit to yes or no.

Common Belief: Postman has built-in flow control like loops and conditionals without scripting.

Reality: Complex flow control requires writing JavaScript in pre-request and test scripts; Postman does not have visual flow control blocks.

Why it matters: Expecting visual flow control leads to frustration and underutilization of Postman's scripting power.

Quick: Do you think environment variables are the same as global variables in Postman? Commit to yes or no.

Common Belief: Environment and global variables behave the same and can be used interchangeably.

Reality: Environment variables are specific to a chosen environment and override globals; globals persist across environments.

Why it matters: Confusing scopes causes unexpected variable values and test errors.

Expert Zone

1

Postman variable scopes have a hierarchy that affects which value is used; understanding this prevents subtle bugs.

2

Using pm.sendRequest inside scripts allows dynamic requests within flows, enabling advanced scenarios beyond static collections.

3

Chaining requests with dynamic URLs and bodies requires careful timing and variable management to avoid race conditions.

When NOT to use

Flow creation in Postman is not ideal for very complex workflows requiring advanced branching or parallel execution; in such cases, dedicated API testing frameworks or custom code may be better.

Production Patterns

Professionals use flow creation to automate end-to-end API tests, integrate with CI/CD pipelines for continuous testing, and simulate user journeys by chaining authentication, data setup, and action requests.

Connections

State Machines (Computer Science)

Flow creation models API interactions as a sequence of states and transitions.

Understanding flows as state machines helps design robust tests that handle all possible API states and transitions.

Assembly Line (Manufacturing)

Flow creation is like an assembly line where each step depends on the previous one to build the final product.

Seeing flows as assembly lines clarifies why order and data passing are critical for success.

Workflow Automation (Business Process)

Flow creation automates repetitive tasks by defining a sequence of actions triggered automatically.

Knowing business workflow automation principles helps optimize API test flows for efficiency and coverage.

Common Pitfalls

#1 Not extracting and saving response data for use in later requests.

Wrong approach:

pm.test('Status is 200', () => {
pm.response.to.have.status(200);
});
// No variable saved here

Correct approach:

pm.test('Status is 200', () => {
pm.response.to.have.status(200);
});
const jsonData = pm.response.json();
pm.environment.set('userId', jsonData.id);

Root cause:

Learner assumes data is shared automatically without scripting.

#2 Running requests manually instead of using Collection Runner for flows.

Wrong approach:

Clicking each request one by one in the Postman app to run a flow.

Correct approach:

Using the Collection Runner to execute all requests in order automatically.

Root cause:

Not understanding how Postman sequences requests in flows.

#3 Using global variables when environment variables are needed for context-specific data.

Wrong approach:

pm.globals.set('token', 'abc123');
// Used in all environments

Correct approach:

pm.environment.set('token', 'abc123');
// Scoped to current environment

Root cause:

Confusing variable scopes and their impact on test isolation.

Key Takeaways

Flow creation in Postman automates running multiple API requests in sequence, sharing data between them to simulate real interactions.

Using variables and scripts is essential to pass data and control the flow dynamically.

Collections organize requests into runnable flows, and the Collection Runner automates executing these flows with different data sets.

Understanding variable scopes and scripting unlocks powerful, flexible API testing beyond simple requests.

Advanced flows handle errors and conditions, making tests robust and closer to real-world API usage.