Folder hierarchy in Postman - Deep Dive

Overview - Folder hierarchy

What is it?

Folder hierarchy in Postman is a way to organize your API requests into nested folders. It helps you group related requests together so you can find and run them easily. Each folder can contain requests or other folders, creating a tree-like structure. This makes managing large collections simpler and clearer.

Why it matters

Without folder hierarchy, your API requests would be a long, unorganized list, making it hard to find or run specific tests quickly. This slows down your work and increases mistakes. Folder hierarchy solves this by grouping requests logically, improving efficiency and reducing errors in testing workflows.

Where it fits

Before learning folder hierarchy, you should understand how to create and send basic API requests in Postman. After mastering folder hierarchy, you can explore advanced features like environment variables, test scripts, and automated test runs using collections.

Mental Model

Core Idea

Folder hierarchy is like a filing cabinet that organizes your API requests into nested folders for easy access and management.

Think of it like...

Imagine your API requests are papers on your desk. Without folders, they are messy and hard to find. Using folder hierarchy is like putting those papers into labeled folders and subfolders inside a filing cabinet, so you can quickly find what you need.

Collection
├── Folder A
│   ├── Request 1
│   ├── Request 2
│   └── Subfolder A1
│       └── Request 3
└── Folder B
    └── Request 4

Build-Up - 6 Steps

1

Foundation

Understanding Postman Collections

Concept: Learn what a Postman collection is and how it groups API requests.

A Postman collection is a container for API requests. It lets you save and organize requests you want to test. Think of it as a folder that holds all your API calls for a project.

Result

You can create a collection and add requests to it, keeping your API tests in one place.

Knowing collections is essential because folder hierarchy exists inside collections to organize requests better.

2

Foundation

Creating Basic Folders in Collections

Concept: Learn how to create folders inside a collection to group requests.

Inside a collection, you can create folders by clicking 'Add Folder'. Name the folder to represent a group of related API requests, like 'User APIs'. Then, add requests into this folder.

Result

Your collection now has a folder that groups related requests, making it easier to find them.

Folders help break down large collections into manageable parts, improving clarity.

3

Intermediate

Using Nested Folders for Deeper Organization

🤔Before reading on: do you think folders can contain other folders or only requests? Commit to your answer.

Concept: Folders can contain other folders, creating a nested hierarchy.

You can create subfolders inside folders to organize requests even more specifically. For example, inside 'User APIs', create 'Authentication' and 'Profile' subfolders. This nesting helps manage complex projects.

Result

Your collection has a tree structure with folders inside folders, grouping requests logically.

Nested folders allow scalable organization, preventing clutter as your API tests grow.

4

Intermediate

Managing Folder Properties and Settings

🤔Before reading on: do you think folders can have settings like authorization or variables? Commit to your answer.

Concept: Folders can have their own settings that apply to all requests inside them.

You can set authorization, pre-request scripts, or variables at the folder level. These settings apply to every request inside that folder, saving time and ensuring consistency.

Result

Requests inside the folder inherit the folder's settings unless overridden individually.

Folder-level settings reduce repetition and help maintain consistent test environments.

5

Advanced

Running Folder Hierarchies in Automated Tests

🤔Before reading on: do you think you can run tests on a whole folder or only individual requests? Commit to your answer.

Concept: You can run all requests inside a folder or nested folders as a group in automated test runs.

Postman lets you run a folder or subfolder in the Collection Runner. This executes all requests inside, respecting folder-level settings and scripts. It helps automate testing of grouped APIs.

Result

You get a test run report for all requests in the folder, making batch testing efficient.

Running folders as units streamlines testing workflows and supports continuous integration.

6

Expert

Optimizing Folder Hierarchy for Collaboration

🤔Before reading on: do you think folder hierarchy affects team collaboration? Commit to your answer.

Concept: A well-designed folder hierarchy improves team collaboration and reduces conflicts.

When teams share collections, a clear folder structure helps everyone find and update requests without confusion. Naming conventions and consistent folder use prevent duplicated work and merge conflicts.

Result

Teams work faster and with fewer errors when folder hierarchy is thoughtfully planned.

Understanding folder hierarchy's impact on collaboration helps build maintainable, scalable test suites.

Under the Hood

Postman stores collections as JSON files where folders are objects containing arrays of requests or other folders. When you run a folder, Postman traverses this JSON tree, applying folder-level settings to each request dynamically before sending. This hierarchical inheritance ensures settings cascade properly.

Why designed this way?

The folder hierarchy mimics familiar file systems, making it intuitive. Using JSON allows easy sharing and version control. Inheritance of settings reduces duplication and errors, supporting large, complex API projects.

Collection (JSON object)
├── Folder (object)
│   ├── Settings (auth, scripts)
│   ├── Requests (array)
│   └── Subfolders (array of Folder objects)
└── Requests (array)

Myth Busters - 4 Common Misconceptions

Quick: Do folder settings override request settings or vice versa? Commit to your answer.

Common Belief: Folder settings always override individual request settings.

Reality: Individual request settings override folder settings if both exist.

Why it matters: Assuming folder settings always override can cause unexpected test behavior and debugging confusion.

Quick: Can you run only part of a folder's requests by selecting some requests? Commit to your answer.

Common Belief: You can select and run only some requests inside a folder directly.

Reality: Postman runs all requests in a folder or subfolder; partial runs require separate folders or manual selection.

Why it matters: Misunderstanding this leads to inefficient test runs and difficulty isolating tests.

Quick: Does nesting folders infinitely improve organization? Commit to your answer.

Common Belief: More nested folders always make organization better.

Reality: Too deep nesting can make navigation confusing and slow.

Why it matters: Over-nesting reduces usability and increases maintenance overhead.

Quick: Are folders just visual groups with no effect on test execution? Commit to your answer.

Common Belief: Folders only organize visually and do not affect test runs or settings.

Reality: Folders affect test execution by applying settings and controlling run scopes.

Why it matters: Ignoring folder effects can cause unexpected test results and wasted debugging time.

Expert Zone

1

Folder-level pre-request and test scripts run before and after every request inside, enabling shared setup and teardown logic.

2

Environment and global variables can be overridden at folder level, allowing flexible test configurations per folder.

3

When exporting collections, folder hierarchy is preserved in JSON, but some tools may flatten it, causing integration issues.

When NOT to use

Avoid deep folder hierarchies for very small collections; use tags or naming conventions instead. For highly dynamic test suites, consider external test runners or code-based frameworks for more control.

Production Patterns

Teams often create folders per API resource (e.g., Users, Orders) and subfolders for actions (e.g., Create, Update). Folder-level auth is set for protected APIs, and folders are run in CI pipelines for automated regression testing.

Connections

File System Hierarchy

Folder hierarchy in Postman mimics file system folder structures.

Understanding file systems helps grasp how nested folders organize and inherit properties.

Object-Oriented Programming (OOP) Inheritance

Folder settings inheritance is similar to class inheritance in OOP.

Knowing inheritance in OOP clarifies how folder-level settings cascade to requests.

Project Management Task Breakdown

Breaking down API tests into folders resembles decomposing projects into tasks and subtasks.

This connection shows how hierarchical organization improves clarity and teamwork across domains.

Common Pitfalls

#1 Creating too many nested folders making navigation confusing.

Wrong approach:

Collection
├── Folder A
│ └── Subfolder A1
│ └── Subfolder A1a
│ └── Subfolder A1a1
│ └── Request 1

Correct approach:

Collection
├── Folder A
│ ├── Subfolder A1
│ └── Request 1

Root cause:

Believing deeper nesting always improves organization without considering usability.

#2 Setting authorization only on folder but overriding it unknowingly in requests.

Wrong approach:

Folder 'User APIs' has Bearer Token auth; Request inside sets No Auth.

Correct approach:

Either set auth only at folder or ensure requests do not override unless needed.

Root cause:

Not understanding that request-level settings override folder-level settings.

#3 Trying to run only some requests inside a folder without separating them.

Wrong approach:

Selecting some requests inside a folder and clicking 'Run' expecting partial execution.

Correct approach:

Create separate folders for different test groups or run requests individually.

Root cause:

Misunderstanding how Postman runs folders as whole units.

Key Takeaways

Folder hierarchy organizes API requests into nested groups, making large collections manageable.

Folders can contain other folders and requests, creating a tree structure that supports scalable organization.

Folder-level settings apply to all contained requests but can be overridden individually.

Running folders lets you execute grouped tests efficiently, supporting automation and collaboration.

Good folder design improves team workflows and reduces errors, but over-nesting can hurt usability.

Practice

1. What is the main purpose of using folders in Postman collections?

easy

A. To create user accounts in Postman

B. To write code for API endpoints

C. To change the API server URL

D. To organize API requests into groups for better management

Solution

1. Step 1: Understand folder usage in Postman

   Folders group related API requests inside a collection to keep things organized.

2. Step 2: Identify the correct purpose

   Folders help manage and run related tests easily by grouping requests logically.

3. Final Answer:

   To organize API requests into groups for better management -> Option D

4. Quick Check:

   Folder purpose = Organize requests [OK]

Hint: Folders group requests logically for easy management [OK]

Common Mistakes:

• Thinking folders are for coding API logic
• Confusing folders with environment settings
• Assuming folders change server URLs

2. Which of the following is the correct way to create a folder inside a Postman collection?

easy

A. Right-click the collection and select 'Add Folder'

B. Click 'New' and select 'Environment'

C. Edit the collection and type folder name in URL

D. Drag and drop requests outside the collection

Solution

1. Step 1: Recall Postman UI actions

   To create a folder, you right-click the collection and choose 'Add Folder'.

2. Step 2: Eliminate incorrect options

   Options B, C, and D do not create folders; they relate to environments, editing URLs, or invalid drag actions.

3. Final Answer:

   Right-click the collection and select 'Add Folder' -> Option A

4. Quick Check:

   Create folder = Right-click collection + Add Folder [OK]

Hint: Right-click collection to add folder quickly [OK]

Common Mistakes:

• Choosing environment creation instead of folder
• Trying to create folder by editing URLs
• Dragging requests outside collections

3. Given this folder structure in Postman:

Collection
 ├─ Folder A
 │   ├─ Request 1
 │   └─ Request 2
 └─ Folder B
     └─ Request 3

If you run Folder A, which requests will execute?

medium

A. Request 1 and Request 2

B. Request 1, Request 2, and Request 3

C. Only Request 3

D. No requests will run

Solution

1. Step 1: Understand folder execution scope

   Running a folder executes only the requests inside that folder, not others.

2. Step 2: Identify requests inside Folder A

   Folder A contains Request 1 and Request 2, so only these run.

3. Final Answer:

   Request 1 and Request 2 -> Option A

4. Quick Check:

   Run folder = only its requests [OK]

Hint: Run folder runs only requests inside it [OK]

Common Mistakes:

• Assuming all collection requests run
• Including requests from other folders
• Thinking no requests run when folder runs

4. You created a folder inside a collection but it does not show any requests when you run it. What is the most likely reason?

medium

A. The collection is deleted

B. Postman is offline

C. The folder is empty and has no requests inside

D. You did not save the collection

Solution

1. Step 1: Analyze folder content

   If a folder runs but no requests execute, it likely has no requests inside.

2. Step 2: Check other options

   Collection deletion or Postman offline would cause errors, not empty runs. Not saving collection would prevent folder creation.

3. Final Answer:

   The folder is empty and has no requests inside -> Option C

4. Quick Check:

   Empty folder = no requests run [OK]

Hint: Check if folder contains requests before running [OK]

Common Mistakes:

• Assuming collection deletion causes empty folder run
• Blaming offline status without error
• Forgetting to add requests to folder

5. You want to run tests only for a specific group of related API requests in Postman. How should you organize your collection to achieve this efficiently?

hard

A. Add all requests directly to the collection without folders

B. Create a folder inside the collection and add those requests to it

C. Create multiple collections for each request

D. Use environment variables to filter requests

Solution

1. Step 1: Understand grouping for selective runs

   Folders group related requests so you can run them together easily.

2. Step 2: Evaluate other options

   Multiple collections for each request is inefficient; no folders means no grouping; environment variables do not filter requests.

3. Final Answer:

   Create a folder inside the collection and add those requests to it -> Option B

4. Quick Check:

   Group requests in folder for selective runs [OK]

Hint: Use folders to group and run related requests [OK]

Common Mistakes:

• Creating too many collections for single requests
• Not using folders and running all requests
• Misusing environment variables for request grouping