Postman Interview Questions & Answers (1970)

Postman is an API development and testing platform. It lets QA engineers send HTTP/GraphQL/gRPC requests, chain them, script assertions, run collections in CI via Newman, and mock or monitor APIs — all from a single workspace. In 2026 it's still the most-used API client in QA job postings.

• Reusable collections and environments (dev/QA/prod)
• Built-in JavaScript test runner (pm.test)
• Auth helpers for OAuth2, JWT, AWS SigV4
• Newman for CI/CD execution
• Team workspaces, mocks, and monitors

Collections, Requests, Environments, Variables, Pre-request Scripts, Tests (post-response scripts), Runners, Monitors, Mock Servers, and Newman (CLI).

A group of saved requests organized in folders. Collections are shareable, versioned, and runnable end-to-end via Collection Runner or Newman.

Environments hold key/value pairs (like baseUrl, authToken) that swap per env. Variable scopes: global → collection → environment → data → local, resolved right-to-left (local wins).

Set method to POST, URL, then Body → raw → JSON:

{
  "email": "qa@example.com",
  "password": "secret"
}

Use the Authorization tab. Types include: No Auth, Bearer Token, Basic Auth, Digest, OAuth 1.0/2.0, API Key, AWS Signature. For OAuth2 client credentials you can auto-fetch tokens and reuse them across the collection.

// Pre-request Script
pm.sendRequest({
  url: pm.environment.get("authUrl"),
  method: "POST",
  header: "Content-Type:application/json",
  body: { mode: "raw", raw: JSON.stringify({ user: "qa", pass: "x" }) }
}, (err, res) => {
  pm.environment.set("token", res.json().access_token);
});

Global = available everywhere. Environment = only when that environment is active. Collection = only within that collection. Local = only within that single request execution.

Use the Collection Runner or Newman with -d data.csv. Access columns via {{columnName}} in the request or data.columnName in scripts.

Extract a value in Tests and save it as an environment/collection variable, then reference it in the next request:

const id = pm.response.json().id;
pm.collectionVariables.set("orderId", id);

postman.setNextRequest("Create Order");
// or postman.setNextRequest(null) to stop

pm.test("Status is 200", () => {
  pm.response.to.have.status(200);
});
pm.test("Response has token", () => {
  pm.expect(pm.response.json()).to.have.property("token");
});

const schema = {
  type: "object",
  required: ["id", "email"],
  properties: { id: { type: "integer" }, email: { type: "string" } }
};
pm.test("Schema is valid", () => {
  pm.response.to.have.jsonSchema(schema);
});

Postman ships dynamic variables:

{
  "requestId": "{{$guid}}",
  "createdAt": "{{$isoTimestamp}}",
  "randomEmail": "{{$randomEmail}}"
}

JavaScript that runs before the request. Use it to build signatures, refresh tokens, generate payloads, or set variables.

console.log(pm.response.json());
console.log(pm.response.headers.get("x-request-id"));

Open the Postman Console (Ctrl/Cmd+Alt+C).

pm.response.json().users.forEach((u) => {
  pm.test(`User ${u.id} has email`, () => {
    pm.expect(u.email).to.include("@");
  });
});

Postman's CLI. Runs collections in CI/CD:

newman run smoke.postman_collection.json \
  -e qa.postman_environment.json \
  -d testdata.csv \
  -r cli,junit,htmlextra \
  --reporter-junit-export results.xml

- name: API smoke tests
  run: |
    npm i -g newman newman-reporter-htmlextra
    newman run collections/smoke.json -e envs/qa.json \
      -r cli,htmlextra --reporter-htmlextra-export report.html
- uses: actions/upload-artifact@v4
  if: always()
  with: { name: newman, path: report.html }

Install newman-reporter-htmlextra and add -r htmlextra. See our GitHub Actions CI guide for a full pipeline pattern.

Export the collection + environment JSON and commit to Git, or use Postman's built-in Git sync. Prefer JSON-in-Git for full PR review and diffs.

// Tests tab — add a delay between iterations
setTimeout(() => {}, 500);
// Or use Runner UI "Delay" (ms between requests)

Newman prints exit code 1 on any failure; combine with --bail to stop on first failure, or write a wrapper that re-executes the failed items using the JSON report.

A Postman-hosted endpoint that returns saved example responses. Great for unblocking QA/frontend while the real API is still in dev.

Scheduled runs of a collection (from Postman's cloud) with pass/fail notifications. Use for uptime and contract checks against production.

Choose Body → GraphQL, write the query and variables, then assert on data and errors in Tests:

const body = pm.response.json();
pm.test("No GraphQL errors", () => {
  pm.expect(body.errors).to.be.undefined;
});

pm.test("Under 500ms", () => {
  pm.expect(pm.response.responseTime).to.be.below(500);
});

Body → form-data → set key type to File and pick a file. In Newman, use --working-dir to resolve relative file paths.

Postman is UI-first, quick to author, best for exploratory + smoke + monitoring. REST Assured is Java code, best for deep integration into a JUnit/TestNG framework. Most teams use both. See our API Testing Q&A for the deeper comparison.