POST/CON 25 Keynote Recap: Level 1, the Fragmented Workflow

This blog is the second in a series recapping everything we shared at POST/CON 25. To catch up on the first installment (and see why we’re talking about API development like a video game), start here. Want the full story? Watch the keynote replay:

Today, we’re going to focus on Level 1: The Fragmented Workflow.

Level 1: The Fragmented Workflow

It’s 3pm on a Tuesday. Your team lead drops a Slack message: “Need the user authentication API ready for demo Thursday. Spec should be in the wiki somewhere.”

Two hours later, you’ve found three different versions of the spec across Confluence, a Google Doc, and someone’s personal Notion page. The mock server mentioned in the README returns 404s. The test suite lives in your teammate’s branch, but she’s on vacation. Your frontend teammate is blocked, your PM is asking for updates, and you’re wondering if this is what “moving fast” is supposed to feel like.

Welcome to Level 1 of the API development game: The Fragmented Workflow. The boss we’re trying to defeat here is The Disconnected Stack: a shapeshifter that keeps your specs, tests, mocks, and docs scattered across different tools, leaving teams guessing which version is real.

Mission brief: End the context switching and unite your workflow

Here’s the thing: you shouldn’t have to choose between shipping fast and building something maintainable. Instead of forcing teams to choose between moving fast and doing things right, Postman unifies the API development workflow with executable collections and structured specs in Spec Hub.

Let’s look at how Postman helps you dismantle the Disconnected Stack.

At a glance:

• Collections
• npm and JSR package support
• VS Code extension
• GitHub integration
• Jira Cloud integration
• Spec Hub

Mission 1.1: Design, prototype, iterate

Problem: You’re prototyping in isolation. There’s unclear ownership over specs, and everyone is building based on assumptions.

Objective: Create living, executable API designs that teams can easily find and immediately build against.

Collections: Turn ideas into working APIs

Forget static documentation that goes stale the moment you save it. Postman Collections let you build executable API prototypes that your entire team can run, test, and iterate on immediately.

Here’s what changes when you build with collections:

• Instead of writing specs, build working examples: Create a POST /auth/login request with realistic JSON payloads, add test scripts that validate response schemas, and generate mock responses for different scenarios

• Share working APIs instantly: Send a collection link to your frontend team, and they can start building against realistic mock data while you’re still designing the database schema

• Enable parallel development: QA can fork your collection and add edge case tests, frontend developers can integrate against mocks, and backend teams can implement against clear, tested expectations

Example in action: Your authentication API collection includes login requests with valid/invalid credentials, password reset flows, and token refresh endpoints. Your React team starts building the login form on Monday using your mocks. By Thursday, they just swap the mock URL for your real endpoint—no integration surprises.

npm and JSR package support: Bring real-world logic into your API workflows

Your APIs don’t exist in isolation. They transform data, validate inputs, and connect to services. Now you can import JavaScript packages from npm and JSR directly into your API testing workflows, so you can use the same libraries in Postman that you use in your application code.

What this unlocks:

• Import lodash to transform payloads in pre-request scripts the same way your backend does

• Use joi or zod for comprehensive input validation in your test suite

• Leverage dayjs for date manipulation that matches your application logic

• Apply authentication libraries to generate real tokens for testing

Example in action: Your API tests use the same bcrypt library your backend uses to hash passwords, ensuring your authentication flow tests match production behavior exactly. Your data transformation scripts use lodash methods identical to your microservices, catching integration issues before deployment.

VS Code extension: API development without the alt-tab dance

Why break your development flow to test APIs? The enhanced VS Code extension brings collaborative API development directly into your coding environment.

What you can do:

• Import .env files directly and avoid the tedious, error-prone process of re-creating your variables

• Share reusable test scripts with your team through centralized collections

• Send HTTP, WebSocket, and gRPC requests without opening a browser

Example in action: You’re debugging a user registration endpoint. Without leaving VS Code, you import your local environment variables, send a test request, see it fail, modify the payload inline, and re-test. Your successful request automatically syncs to the shared collection for your teammates.

Mission 1.2: Build, test, deploy

Problem: Your prototype works, but now comes the hard part. Keeping specs, tests, and implementation in sync across three teams while shipping to production without breaking existing integrations.

Objective: Zero handoff delays. Frontend, backend, and QA teams work simultaneously from a single source of truth that stays current automatically.

(New!) GitHub integration: Your API specs and source code, finally in sync

Postman’s GitHub integration keeps your collections and repository in lockstep, enabling true parallel development.

How it transforms your workflow:

• Auto-commit changes to your repo every time you save a collection

• Pull request reviews include API diffs alongside code changes

• CI/CD pipelines run API tests using the exact same collections your team develops with

• Branch-based API development that mirrors your code workflow

Example in action: Your backend developer modifies the user registration endpoint, updates the collection, and commits both changes together. Your frontend teammate automatically gets the updated API spec in their next pull. Your CI pipeline runs integration tests using the same collection. Everything stays synchronized.

(New!) Jira Cloud integration: Streamlined issue tracking

Found a broken endpoint during testing? Postman’s Jira Cloud integration captures the full context and creates actionable tickets without breaking your flow.

When you hit that 500 error, one click creates a Jira issue containing:

• Complete request details (headers, auth tokens, payload)

• Full response and error details

• Environment configuration

• Reproduction steps

Problem solved: No more “it works on my machine” tickets. Every bug report includes enough context to debug immediately.

Spec Hub: Scale your API design without the overhead

When your APIs outgrow rapid prototyping, Spec Hub provides enterprise-grade specification management that doesn’t slow teams down.

What you get:

• Developer-first OpenAPI editing with syntax highlighting and intelligent autocomplete

• Real-time validation that catches schema errors as you type

• Visual navigation through complex API structures

• One-click collection sync when you update your spec

• Built-in governance that enforces standards without blocking progress

Problem solved: Your team maintains authoritative OpenAPI specs that automatically generate working collections, mock servers, and documentation. Changes propagate instantly. Governance happens during development, not after. Everyone works from the same source of truth.

Mission complete: You’ve defeated the Disconnected Stack

Your API development process now looks like this:

• Parallel workflows instead of sequential handoffs

• Living documentation that updates automatically

• Governance that enables rather than blocks progress

• Single source of truth that everyone can trust and build on

No more choosing between moving fast and doing things right. No more hunting for current specs. No more waiting for other teams to finish before you can start.

Ready for Level 2?

You’ve solved the internal coordination problem. Your team ships APIs faster and with more confidence than ever. But here’s the next reality:

Perfect APIs that nobody can find are just expensive hobbies.

Next week, in Level 2: The Distribution Disconnect, we’ll tackle the Invisible API. This boss hides well-designed APIs from the developers, partners, and AI agents who need them most. Because collaboration is just the beginning. Next comes scale.