Postman Will Do for APIs What Github Did for Open Source

I woke up thinking about something Abhinav said recently, “What GitHub did to code, I imagine Postman will do that for APIs, shortening the cycle from using an API to building things with it." Yes! That is how I see Postman. GitHub changed my relationship with code in many ways. Github plays a significant role in how I produce, manage, and evolve the code that I produce for my own side projects and businesses, as well as the code I engage with as part of my job and the projects I work on. This blog post is my mental exercise of thinking through what GitHub has given me when it comes to code, which in my world translates pretty nicely to what I do with APIs. First, I published my thoughts about what GitHub did for code, and now I want to explore what Postman is doing for APIs.

Users

  • Home - Give me a summary home page for my world.
  • Profile - Let me manage my public and private profile.
  • Followers - Let me follow other users Postman profiles.
  • Following - Let people follow my Postman profile.
  • Comments - I want to be able to se all of my comments.
  • Discussions - I want to see my discussions with team members.
  • Settings - Easy configuration of my account.
  • Notifications - Allow me to receive notifications.
  • Reminders - Provide me with reminders of common tasks.
  • Session - Allow me to see all of my sessions.
  • Teams - Help me manage the teams I am on.
  • Organizations - Help me manage the orgs I belong to.
  • Workspaces - Help me manage my workspaces.
  • Identity - Help me manage my identity.
    • Keys - Give me robust API key management.
    • Tokens - Take the friction out of token management.
  • Export - Allow me to export my account.

Organizations

  • Details - Mange the details of my organization(s).
  • People - Manage all the people in my organization(s).
  • Teams - Help me manage many different teams across orgs.
  • Workspaces - Do the hard work of organizing workspaces.
  • APIs - Allow me to manage hundreds or thousands of A?PIs.
  • Collections - Help me manage many derivative API collections.
  • Environments - Generate and manage my environments for me.
  • Mock Servers - Ensure there are mock servers available.
  • Scripts - Assist me in managing the scripts used across operations.
  • Runners - Execute runners manually or as part of pipelines via CLI.
  • Monitors - Helps me effectively run monitors across all APIs.
  • Governance - Provide me with tools for governing API operations.
  • Setting - A robust set of settings for configuring my organizations.
  • RBAC - Give me role based access control for my organizations.

Teams

  • Details - Manage the details of my team(s).
  • Invitations - Easily invite users to be part of teams.
  • Members - Help me manage the members of my teams.
  • Discussions - I want to be able to chat with team members.
  • Reviews - I can assign reviews for my teams.
  • Reminders - I can establish team level reminders.
  • Group - I can group teams within teams, establishing hierarchy.
  • RBAC - Provide me with role based access control for teams.
  • Settings - Allow me to granularly define my team settings.
  • Leave - Allow me to leave any team I have joined.
  • Activity - Show all the activity involved in team management.
  • Audit - Provide me with intelligent auditing tools for my teams.
  • Reports - I want to have easy to read reports for my teams.
  • Usage - Let me know where I am at with my team resource use.

Workspaces

  • Details - Manage the details of my workspace(s).
  • Type - Allow me to have different types of workspaces.
    • Personal - Provide users with personal workspaces.
    • Operation - Establish workspaces that have access to all workspaces.
    • Team - Provide the ability to define team level workspaces.
    • Partner - Help me manage my external relationships using workspaces.
    • Public - Allow me to create a variety of public spaces.
  • RBAC - Provide me with role based access for my teams.
  • Search - Give me a way to search across my workspace.
  • Invitations - Allow me to invite other public, private, and partner users.
  • Members - Allow me to manage who is a member of my workspace.
  • APIs - Provide me what I need to manage my APIs.
  • Collections - Providing me with all I need to manage my collections.
  • Environments - Give me quick access to select, use, and manage environments.
  • History - Give me quick access to the request history across the workspace.
  • Activity - Allow me to see all the activity for management of my workspaces.
  • Monitors - Allow me to see all the monitors that are in use in my workspaces.
  • Mocks - Allow me to see all the mock servers that are in use in my workspaces.
  • Integrations - Allow me to see all the integrations that are in use in my workspaces.
  • Add To - Allow me to add resources from another workspace.
  • Clone - Allow me to easily clone a workspace for other purposes.
  • Import - Allow me to import workspace definitions.
  • Export - Allow me to export workplace definitions.

APIs

  • Listing - List all of my APIs in a workspace.
  • Pin - Let me pin APIs within my workspace.
  • Details - Manage the details of my API(s).
  • Version - Remove friction from versioning my APIs.
  • Define - Allow me to choose which definition I use.
    • OpenAPI 3.0
    • Swagger
    • RAML
    • GraphQL
    • AsyncAPI
    • JSON Schema
  • Design - Provide me with a simple GUI for designing my API.
  • Schema - Provide me with an interface to manage my schema.
  • Components - List all the components used to build APIs.
  • Sync - Allow me to sync my definitions.
    • GitHub
    • GitLab
    • Bitbucket
  • RBAC - Allow me to control who has access to my APIs.
  • Mocks - Allow me to see the associated mock servers.
  • Docs - Allow me to see the associated documentation.
  • Environments - Allow me to see the associated environments.
  • Tests - Allow me to see all of the tests for an API.
  • Monitors - Allow me to see all of the monitors for my APIs.
  • Change Log - Help me manage the change long for my APIs.
  • Comments - Allow me to make and manage comments.
  • Share - Allow for sharing of APIs to other workspaces.
  • Generate Collection - Easily generate a new collection.
  • Clone - Quickly duplicate any of my APIs.
  • Tags - Apply tags to each API.
  • Import - Providing me the ability to import API definitions.
  • Export - Allow me to easily export API definitions.

Components

  • Schema - Standardized schema for use across APIs.
  • Paths - Standardized API paths for use across APIs.
  • Parameters - Standardized parameters for use across APIs.
  • Responses - Standardized API responses for use across APIs.
  • Examples - Standardized examples for use across APIs.
  • Request Bodies - Standardized request bodies for use across APIs.
  • Headers - Standardized headers for use across APIs.
  • Security - Standardized security definitions for use across APIs.
  • Search - Allow me to quickly search and filter components.

Collections

  • Details - Let me easily manage my collections.
  • RBAC - Provide me with role based access control for collections.
  • Folders - Allow me to quickly organize using folders.
    • Description - I want to provide markdown descriptions.
    • Authorization - I want to define authorization at the folder level.
    • Pre-request Scripts - I want to be able to run pre-request scripts at folder level.
    • Test Scripts - I want to be able to run test scripts at folder level.
    • Variables - I want to define variables for folders.
  • Request(s) - I want to have one or many requests in collections.
  • Version - Abstract away the complexity of versioning my collections.
  • Scripts - Provide management tools for scripts across my requests.
  • Documentation - Allow me to publish documentation from my collections.
  • Monitors - Allow me to deploy regional cloud monitors for my collections.
  • Mocks - Allow me to deploy mock servers from my collections.
  • Change Management - Help me manage change for collections.
    • Fork - Allow me to fork collections.
    • Pull Requests - Allow me to receive pull requests for collections.
    • Merge - Allow me to merge my collections.
  • Version Tags - Allow me to apply version control tags to my collections.
  • Validation - Provide validation for collections against APIs.
  • Change Log - Make the change log for my collections accessible.
  • Share - Allow me to share a collection to workspace or via link.
  • Sync - Sync my collections for me.
    • GitHub
    • GitLab
    • Bitbucket
  • Button - Allow me to generate a Run in Postman button.
  • Examples - Allow me to define one or many examples for use across requests.
  • Duplicate - Give me the ability to quickly duplicate a collection.
  • Import - Allow me to import collections.
  • Export - Allow me to export collections.
  • Tags - Apply tags to collection.

Requests

  • Name - I want to be able to name my requests.
  • Description - I want to have descriptions for each request.
  • Protocol - I want to be able to use multiple protocols.
    • HTTP 1.1, HTTP/2
      • Request
        • Method - Select the HTTP method.
        • URL - Provide a URL for the aPI.
        • Params - Define the parameters.
        • Authorization - Let me define my auth.
        • Request Headers - Let me define my headers.
        • Body - Give me control over the body.
        • Pre-request Scripts - I need scripts to run before request.
        • Tests - I need scripts to run after the request.
        • Settings - I need to be able to define request settings.
        • Cookies - I need control over my cookies.
      • Response
        • Body - Let me see the body of the response.
        • Cookies - Let me see the cookies for each response.
        • Headers - Let me see the headers for each response.
        • Test Results - Let me see the test results for each response.
        • Status - Provide me with the status for each response.
        • Time - Provide me with the time a response took.
        • Size - Provide me with the size of each response.
        • Save Example - Allow me to save response as example.
        • Visualize - Allow me to see response visualization.
        • Media Type - Allow me to see each available media type.
        • Save Response - Allow me to save each response.
        • Search Response - Allow me to search details fo response.
      • Webhooks - Allow me to define a webhoook response.
    • HTTP/2, HTTP/3, TCP, MQTT</li>
      • Channels - Allow me to subscribe to the available channels.
      • Operations - Allow me to perform publish or subscribe operations.
      • Messages - Allow me to work with messages published and received.
      • Schema - Provide me the ability to manage my schema used.
      • Sampling - Allow me to see sampling of data returned.
  • Storage - Allow me to define storage for request, subscriptions, and streams.
  • Environment - Which environment should be applied against the request.
  • Snippets - Give me access to code snippets to put APIs to work.
  • Examples - Allow me to manage examples across requests.
  • Send - Allow me to send requests.
  • Receive - Allow me to receive web hooks.
  • Subscribe - Allow me to subscribe to streams.
  • Save - Allow me to quickly save my requests to collections.
  • Duplicate - Allow me duplicate requests for easy replication.
  • Comments - Allow me to comment on each individual request.
  • Tags - Apply tags to each request.

Examples

  • Name - The name of example
  • Request
    • Method - The HTTP method.
    • URL - The URL used.
    • Parameters - The query and path parameters.
    • Headers - The headers used.
    • Body - The request body.
  • Response
    • Headers - The response headers.
    • Body - The body returned.
    • Status Code - The status code returned.
    • Media Type - The media type of response.
  • Synthetics - Auto generate synthetic data for me.
  • Duplicate - Duplicate examples to help them grow.
  • Request(s) - The requests where example is used.
  • Tags - Apply tags to the example.

Environments

  • Name - I want to be able to name my environments.
  • RBAC - Provide me with role based access control over environments.
  • Versioning - Help me version and manage change for environments.
  • Variables - I want to be able to define variables.
    • Keys - Provide the keys for the variables.
    • Initial Values - Define the initial value
    • Current Values - Define the current value.
    • Descriptions - Provide descriptions for each.
  • Share to Workspace - Share environments to workspaces.
  • Remove from Workspace - Remove an environment from workspace.
  • Duplicate - Allow me to duplicate any environment.
  • Comments - Allow me to comment on each environment.
  • Import - Allow me to import environments.
  • Export - Allow me to export environments.
  • Tags - Allow me to apply tags to environments.

Identity

  • Provider(s) - I want to be able to mange multiple identify providers.
  • Secrets - I want to easily manage secrets that I generate.
  • Vault - Provide me with a vault for storing of my secrets.
  • Environment - Allow me to associate environments.
    • Variables - Allow me to attach environments.
  • Refresh - Provide the ability to refresh tokens behind the scenes.
  • Audit - Allow me to audit how identity is applied across operations.
  • Comments - Allow for commenting on identities.
  • Tags - Allow me to apply tags to identities.

Storage

  • Details - All me to define a variety of storage options for operations.
  • Providers - Allow me to use a variety of data storage providers.
  • RBAC - Provide me with role based control over storage.
  • Key / Value - Provide me with simple key / value storage.
  • Buckets - Provide me with object storage using buckets.
  • Lakes - Allow me to define data lakes for use across aPIs.
  • Comments - Allow me to comment on storage solutions.
  • Tags - Apply me to tags to storage.

Mock Servers

  • Generate - Allow me to easily generate mock servers.
  • Details - Allow me to manage the details of my mock servers.
  • Collection - Allow me to define which collection is used.
  • Version Tag - Provide me the ability to apply versioning.
  • Environment - Provide the ability to associate environments.
  • RBAC - Give me access control over my mock servers.
  • Server URL - Provide quick acacias to the mock URL.
  • Private - Allow me to make mock servers private.
  • Comments - Allow me to comment on mock servers.
  • Tags - Provide me the ability to apply tags to mock servers.

Deployment

  • Details - Allow me to manage the details of deployments.
  • Provider - Allow me to use multiple providers for Deployment.
  • Collections - Allow me to leverage collections for deployment.
  • Scripts - Allow me to manage the scripts that are deployed.
  • Environments - Let me use environments to define deployment.
  • Stages - Let me define which stages of deployment I use.
  • Tags - Allow me to apply tags to each deployment.

Management

  • Plans - Allow me to manage usage plans for my APIs.
  • Policies - Allow me to apply access policies to APIs.
  • Identity - Allow me to use identities for access APIs.
  • Keys - Allow me to generate keys for API access.
  • Tags - Allow me to tag each of my plans and keys.
  • Usage - Show me usage for each of my APIs.

Scripts

  • Search - Quick search and filter of scripts.
  • Listing - Listing of all scripts in use across operations.
  • Details - Let me define meta data for scripts.
  • Code - Let me manage code for each script.
  • Dependencies - Let me define my dependencies.
  • Testing - Let me test my scripts for quality.
  • RBAC - Let me define access control for scripts.

Packages

  • Publish - I want to be able to publish packages using Postman.
  • Install - I want to be able to install and manage my packages.
  • Authenticate - Help me authenticate my packages.
  • Dependencies - Help me manage my package dependencies.

Runners

  • Collection - Allow me to define a collection for a runner.
  • Environment - Allow me to define the environment for a runner.
  • Iterations - Let me define how many iterations to run.
  • Delay - Let me define what the delay should be.
  • Data File - Allow me to provide a data file for running.
  • Data Store - Allow me to store data returned in key / value, bucket, or lake.
  • Results Store - Allow me to store the results of the run.
  • Manual Run - Allow me to run manually via client.
  • Command Line - Help me run easily using the CLI.
  • History - Provide me with history of each run.

Monitors

  • Details - Allow me to manage the details of my monitors.
  • Region - Let me select the region to run each monitor.
  • Status - Let me know the status of each monitor.
  • Average success rate - Report to me the average success rate.
  • Average response time - Report to me the average response time.
  • Monitor Summary - Give me a summary of monitor runs.
  • Request Split - Show a split view of the run history.
  • Filter Requests - Allow me to filter requests that are made.
  • Manual Run - Let me manually run my monitors.
  • Pause - Allow me to pause a monitor while running.
  • Tags - Let me apply tags to my monitors.

Testing

  • Results
    • Monitors - Show me the results of testing monitors.
    • Runs - Show me the results of testing runs.
    • Reports - Provide me quick access to reports.
  • Collections - Let me get at the collections behind tests.
  • Scripts - Let me get at the scripts behind tests.
  • Versioning - Help me version my scripts.
  • Syncing - Sync my scripts.
    • GitHub
    • GitLab
    • Bitbucket

Events

  • Organization - Details of organizational events.
  • User - Details of user events.
  • Team - Details of team events.
  • Workspace - Details of workspace events.
  • APIs - Details of apis events.
  • Collections - Details of collections events.
  • Environments - Details of environments events.
  • Identity - Details of identity events.
  • Scripts - Details of script events.
  • Tests - Details of tests events.
  • Monitors - Details of monitors events.
  • Runners - Details of runners events.
  • Deployment - Details of deployment events.
  • Management - Details of management events.
  • Mock Servers - Details of mock server events.
  • Documentation - Details of documentation events.
  • Components - Details of component events.
  • Webhooks - Push me information when events occur.
  • Subscriptions - Let me subscribe to event streams.

Documentation

  • Publish - Let me publish API documentation.
  • Collection - Let me define which collection.
  • Version(s) - Allow me to define the version.
  • Environment(s) - Let me associate environments.
  • Domain - Allow me to define a domain.
  • Styling - Let me apply styling to documentation.
  • Network
    • Private - Let me make documentation private.
    • Partner - Let me invite external users to docs.
    • Public - Let me make my documentation public.
  • Template - Let me publish as a template.
  • Run in Postman - Provide me a run in Postman button.
  • Code Snippets - Provide me code snippets with docs.
  • Team - Allow me define the team behind documentation.
  • Share - Make it easy for me to share my documentation.
  • Download (PDF) - Allow anyone to download as PDF
  • Tags - Let me apply tags to my documentation.

Integrations

  • Listing - Provide me with a list of integrations.
  • Details - Give me the details of integrations.
  • Star - Allow me to star and see popular integrations
  • Browse - Let me browse for integrations.
  • Publish - Allow me to publish my own integrations.
  • Remove - Let me remove my integrations.
  • Tags - Let me apply tags to integrations.

Security

  • Users - Help me manage the security of my users.
  • Workspaces - Help me manage the security of my workspaces.
  • APIs - Help me manage the security of my APIs.
  • Environments - Help me manage the security of my environments.
  • Identities - Help me manage the security of my identities.
  • Secrets - Help me scan for and secure all of my secrets.
  • Advisories - Provides me with real time security advisories.
  • Vulnerabilities - Help me tune into the wider vulnerability threat.
  • Dependencies - Help me see all of my dependencies.

Reports

  • Team - Provide me reports on my teams.
  • Network - Provide me reports on my networks.
  • Workspaces - Provide me reports on my workspaces.
  • APIs - Provide me reports on my APIs.
  • Collections - Provide me reports on my Collections.
  • Environments - Provide me reports on my Environments.
  • Identity - Provide me reports on my identities.
  • Storage - Provide me reports on my storage.
  • Deployment - Provide me reports on my deployment.
  • Management - Provide me reports on my management.
  • Documentation - Show me reports on my documentation.
  • Mocks - Provide me reports on my mocks.
  • Monitors - Provide me reports on my monitors.
  • Runners - Provide me reports on my runners.
  • Testing - Provide me easy access to all test results.
  • Integrations - Provide me reports on my integrations.
  • Tags - Provide me reports grouped by tags for a cross view.

Visualizations

  • Requests - Let me define requests behind visualizations.
    • Collections - Let me define the collections behind visualizations.
    • Environment - Let me allow to define environments for visualizations.
    • Scripts - Let me manage the scripts behind requests.
  • Monitor - Let me setup monitors to regularly update a visualization.
  • Publish - Let me publish visualizations to a dashboard.
  • Embed - Provide me with embeddable versions of visualizations.
  • Views - Show me how many times a visualization is viewed.
  • Tags - Allow me to tag my visualizations.

Network

  • Scope - Provide me with different scopes of network.
    • Private - My internal organizational network.
    • Partner - My external collaborator network.
    • Public - A public network to get more exposure.
  • Browse
    • Workspaces - Let me browse available workspaces.
    • Teams - Let me browse available teams.
    • Collections - Let me browse available collections.
    • Templates - Let me browse available templates.
    • Visualizations - Let me browse available visualizations.
    • Environments - Let me browse available environments.
    • Scripts (Trending) - Let me browse available scripts.
  • Search
    • Workspaces - Let me search for available workspaces.
    • Teams - Let me search for available workspaces.
    • APIs - Let me search for available workspaces.
    • Collections - Let me search for available workspaces.
    • Templates - Let me search for available workspaces.
    • Environments - Let me search for available workspaces.
    • Scripts - Let me search for available workspaces.
    • Visualizations - Let me search for available workspaces.
    • Activity - Let me search for available workspaces.
    • Comments - Let me search for available workspaces.
    • History - Let me search for available workspaces.
  • Details
    • Documentation - Let me access documentation for APIs.
    • Run in Postman - Let me run in postman.
  • Publish<
    • Documentation - Let me publish my docs.
    • Tags - Let me apply tags to my documentation.

Comments

  • APIs - I want to be able to see comments by API.
  • Collections - I want to be able to see comments by collection.
  • Examples - I want to be able to see comments by example.
  • Mocks - I want to be able to see comments by mock server.
  • Monitors - I want to be able to see comments by monitor.
  • Runners - I want to be able to see comments by runner.
  • Tags - I want to be able to see comments by tag.

History

  • Timeline - I want history organized by timeline.
  • Requests - I want to search history of each request.
  • Save - I want to be able to save a request to collection.
  • Monitor - I want to be able to monitor a request.
  • Document - I want to be able to document a request.
  • Mock - I want to be able to mock a request.
  • Tags - I want to be able to tag a request.

Activity

  • Organizations - I want to see activity managing organizations.
  • Users - I want to see activity managing users.
  • Workspaces - I want to see activity managing workspaces.
  • APIs - I want to see activity managing APIs.
  • Collections - I want to see activity managing collection.
  • Environments - I want to see activity managing environments.
  • Monitors - I want to see activity managing monitors.
  • Mock Servers - I want to see activity managing mock.
  • Runners - I want to see activity managing runners.

Search

  • Organizations - I want to be able to search for organizations.
  • Users - I want to be able to search for users.
  • Teams - I want to be able to search for teams.
  • Workspaces - I want to be able to search for workspaces.
  • APIs - I want to be able to search for apis.
  • Collections - I want to be able to search for collections.
  • Environments - I want to be able to search for environments.
  • Identity - I want to be able to search for identity.
  • Storage - I want to be able to search across storage.
  • Monitors - I want to be able to search for monitors.
  • Runners - I want to be able to search for runners.
  • History - I want to be able to search for history.
  • Activity - I want to be able to search for activity.

Postman API

  • Overview - Gives me what I need to get started using the Postman API.
  • Documentation - The documentation is simple, helpful, and up to date.
  • Coverage - The API covers most of the features available on web and desktop,
  • Status - They provide a status of the API that I will be depending on.

Outcomes

  • People - Helping me engage across teams.
    • Teams - I have teams defined for API operations.
    • Sharing - I can easily share resources across teams.
    • Collaboration - I can easily collaborate with other people.
    • Activity - You can tune into what is happening.
  • Me - The direct impact on me.
    • Tangible - My APIs are more tangible.
    • Coherent - I can see what is happening.
    • Social - The API life cycle has become social.
    • Precise - Allows me to be more precise with my APIs.
  • APIs - Direct impacts on my APIs
    • Defined - Every one of my APIs is defined.
    • Documented - All my APIs have documentation.
    • Mocked - All APIs are available as mocks.
    • Tested - All APIs are fully tested by collections.
    • Consistent - I use common components across APIs.
    • Validated - All of my APIs are validated against collections.
    • Reusable - I can design my APIs so they are reusable.
    • Boundaries - I have well defined boundaries between APIs.
  • Change
    • APIs - I can manage change across the APIs I’m delivering.
    • Collections - I can manage change across my collections.
    • Versioning - I can version all artifacts behind APIs.
  • Deployment
    • Consistent - I can consistently deploy APIs.
    • Multi-Platform - I can deploy with multiple providers.
    • Defined - My deployment process is mapped out.
  • Management
    • Consistent - All APIs can be consistently managed.
    • Visibility - You can see into how APIs are used.
  • Platform
    • Organized - My APIs exist in defined workspaces.
    • Private - I can maintain privacy when needed.
    • Public - I can make things public as needed.
    • Sync - I can sync with other platforms.
    • Integration - I can integrate with other platforms.
    • Centralized - Work can be centralized for scale.
    • Localized - Work can be localized for individuals.
    • Portable - I can sync, integrate, export and share everything.
    • Executable - Everything on my platform is executable.
    • Machine Readable - Everything produces an artifact.
  • Orchestration
    • Collecitons - The collection as central unit of currency.
    • Runners - Being able to run my collections as I need.
    • Monitors - Letting me schedule the runs of collections.
    • Environments - Terraforming of environments to evolve.
    • Pipelines - Deploy code using repeatable, tested pipelines.
    • Events - Make my world about responding to events not just requests.
  • Access Control
    • Organization - We can control access across teams.
    • Teams - I can manage access at the team level.
    • APIs - I can manage access at the aPI level.
    • Collections - I can manage access at the collection level.
    • Environments - I can manage access at the environment level.
    • Scripts - I can can manage access to all the scripts.
    • Mock Servers - I can manage access to mock servers.
  • Discovery
    • Private - Discoverable via private networks and workspaces.
    • Partner - Discoverable via partner networks and workspaces.
    • Public - Discoverable via public networks and workspaces.
    • Automated - Make everything discoverable by default for me.
    • Integration - I have a wealth of 3rd party integrations available.
    • Search - You can search across APIs and operations.
  • Observability
    • Teams - You can see across teams.
    • Workspaces - You can see across workspaces.
    • Documented - I can see docs for everything.
    • Tests - Everything can have a test.
    • Scripts - I can holistically manage scripts.
    • Monitoring - I can monitor everything.
    • Management - I can see all API usage.
    • History - All API activity is logged.
    • Activity - All management activity is logged.
    • Provenance - Everything is reverse engineer-able.
    • Traceability - All requests have unique ID.
  • Awareness
    • Insights - Postman regularly shows me new things about my own APIs.
    • Zeitgeist - Postman provides the pulse of I need to stay in tune with.
    • Reports - I have reporting for every dimension that is available to me.
    • Prioritize - Postman has helped me understand what is a priority.
  • Security
    • Scanning - I need help scanning the growing sprawl I am building.
    • Standardization - Helping me do things using proven standards.
    • Privacy - Help me understand and protect privacy across my API infrastructure.
  • Feedback Loops
    • Discussions - There are discussions across teams.
    • Comments - All artifacts have inline comments.
    • Change Log - You can see what happened asynchronously.
  • Community
    • Discovery - I am regularly discovering new code, process, and techniques using Postman.
    • Network - I see Postman as a social network before I see it being about APIs.
    • Rating - There is a social rating system in place on top of the Postman platform.
    • Public - Postman is the public place I go to find out what is happening with APIs.
    • Taxonomy - An organic taxonomy of topics, labels, and other elements surfaces.
    • People - Even with its technological roots, Postman is now very much about people and teams.

Distilling All of That Down

As I sit here thinking about what GitHub has done for me with code, and what Postman will do for me with APIs loaded in my head I can comfortably sit back and ponder on the shift we are going to need in the API universe. I see a little over 10 years of GitHub and 5 years of Postman in my head. I can think about the fundamental shifts in how I work because of both GitHub and Postman. I am spending tie thinking about what I want, but also other what business and technical leadership is going to want from their own API infrastructure and their service providers. Most importantly I want to also make sure I tune into what developers on the ground within the enterprise, small business, and other independent shops will want when it comes to their API operations. Here is what I distilled all this brainstorming down into…

  • About the Organization and People - Postman has to address the organizational shift that has been set into motion with APIs, helping strike a balance between the business and human needs and motivations that exist across an organization or even an industry.
  • Stabilizing Private, Partner, and Public - Private, partner, and public APIs has long been used to describe the critical ways in which organizations do aPIs, and Postman has to help draw definitive lines, provide enterprise grade access control, and whatever is needed to navigate these layers.
  • Bringing Consistency and Reliability - Doing APIs well is difficult at scale, and Postman has to help API providers achieve more heightened levels of consistency and reliability across operations by helping standardize and test APIs across the entire API life cycle.
  • Discoverable and Tangible by Default - The number of APIs are growing and we are all going to need help making sure what we are building is tangible, meaningful, and discoverable, otherwise it will get lost in the noise of the API factory floor that is perpetually moving forward in tomorrow.
  • Everything is Portable and Executable - Postman has to make not just APIs, but the infrastructure we use to deliver them as portable, executable, reusable as possible helping API providers build out their API factor floors in a way that evolve in the same ways we are enabling our web, mobile, device and network apps.
  • Security and Privacy Baked Into DNA - Keeping our infrastructure secure is only going to get harder, and API providers and consumers. need as much help as they can get when it comes to identity, authentication, scanning, standards, vulnerabilities, dependencies, and everything else plaguing the digital world.
  • Healthy Observability and Accountable - Postman provides a wealth of existing outputs from the enterprise factory floor that can be harvest and used to make sense of what is going on, introducing healthier levels of observability and accountability across how APIs are doing what they do.
  • he Tooling for Orchestrating it All - The Postman platform provides all of the desktop, web, and open source tooling for delivering APIs throughout over time, helping API providers make sense of their ever evolving enterprise landscape, while also empowering API consumers to keep up with the pace of change.

If Postman is going to do for APIs what GitHub has done for code, I feel like it has to be rooted in these areas. I was using Git long before GitHub came along. It was their very public and social usage of Git that shifted my behavior. GitHub provided me with tools to help address the growing need to do business on the open web, as well as within the enterprise. GitHub helped play a role it breaking down the proprietary enterprise software monolith by applying a more modular, open source, versioned, and human way of moving software forward. Postman needs to ensure that many of the nutrients that allowed the GitHub community to flourish out in the open as well as on-premise within the enterprise firewall exists. However, Postman also has to help lead the conversation when it comes to API at this level because we are in uncharted territory and the GitHub blueprint doesn’t provide us with everything we need to drive the conversation in the next decade, but it can help inform us.

That was a pretty fun exercise. I do not do this because I think it holds all the answers. I don’t do these because I think anyone is going to read it all and understand where I am coming from. I do it because it helps me see the entire chess board. It also provides me with a game to play in my head while trying to relax. I don’t see this as work. I like thinking about the moving parts of the API life cycle. If nothing else I am just more equipped for my next conversation with a customer about APIs, and all of these nuggets are on the tip of my tongue, ready to be spoke.