# We Mapped 115 Microservices for Our Coding Agents — Kamalakannan Nandagopal, Postman

## Executive summary

The talk details how Postman built an API context graph to enable coding agents to function effectively within large, distributed microservices architectures. Since traditional coding agents excel in single-project contexts, the speaker argues that APIs must serve as the central 'context layer.' The graph maps every microservice, endpoint, implementation detail, and data flow (down to databases and caches), grounded in either production telemetry or source code. This approach significantly improves agent performance in tasks like API discovery, redesign analysis, and impact assessment, though maintaining the graph's freshness is critical.

## Key takeaways

- APIs as the Context Layer: In distributed microservices systems, APIs define the boundaries and responsibilities of each service. The API context graph is necessary to provide agents with the holistic context required to understand complex, cross-system workflows.
- High API Dependency Rate: Analysis of Postman's top 10 repositories revealed that approximately 75% of all Pull Requests (PRs) affected APIs, highlighting the critical importance of API-centric tooling.
- Graph Grounding Requirement: Every data point added to the context graph must be grounded in a 'hard truth': either a line of code from the codebase or an exact trace from production telemetry.
- Graph Maintenance is Crucial: The system's failure to accurately assess impact was traced back to a gap in the context graph—specifically, new consumers were introduced between the time the evaluation was written and when it was run, demonstrating the need for continuous synchronization.

## Technical details

- API Context Graph Construction: The graph was built by cataloging every microservice and exposed REST API endpoint, mapping implementation details down to the line of code, tracking inter-service communication, and tracing data flow across the entire stack (including databases and caches).
- Agent Evaluation Methodology: Evals were run using real PRs and key design decisions from Postman's Git repos. The agent's performance was scored (0-5 scale) and compared against a generic coding agent (Claude code) and pure code search, measuring both quality and token efficiency.
- Use Case: API Discovery: The context graph significantly outperformed pure code search in identifying the correct API to call for a given task (e.g., getting a user profile name), demonstrating superior contextual awareness.
- Use Case: API Redesign/Impact Assessment: The graph allowed the agent to accurately determine the unique input shapes and consumers for an API, even when the initial design was incomplete. It also excelled at impact assessment, identifying downstream services affected by a change, often with significantly fewer tokens than pure code search.

## Practical implications

- Enables coding agents to perform complex, cross-service analysis (e.g., end-to-end architecture reviews) that were previously impossible within a single repository.
- Reduces the time and effort required for developers to understand the full impact of a proposed change (impact assessment).
- Provides a mechanism to capture and share 'tribal knowledge' about an ecosystem's APIs, making it accessible to all developers.
- Facilitates proactive identification of technical debt, such as dependency cycles and single points of failure, before deployment.

## Topics

Coding Agents, Microservices Architecture, API Design, Context Graph, Software Development Lifecycle (SDLC), Telemetry and Observability, Postman Context Graph API, Context Graph docs

Source: https://www.youtube.com/watch?v=k2ClBT4aqAg