APIs and Functions: What Every PM Must Know

The actual job of a product manager is to deliver value to users through technology. To do that, you must understand the building blocks that engineers use to make your product work. APIs and functions are two of the most fundamental concepts in software today — they are the levers you pull to connect systems, automate workflows, and create seamless user experiences.

If you do not grasp these concepts clearly, you will struggle to make trade-offs about scope, timelines, and technical feasibility. You will lose credibility with your engineering team and risk delivering products that fail to meet user needs or business goals.

The rest of this lesson teaches you how to think about APIs and functions from a PM perspective — not as a developer, but as a leader who must translate technical realities into product decisions.

Why PMs must understand APIs and functions

APIs — Application Programming Interfaces — are contracts between software components. They allow different systems, services, or modules to communicate and exchange data in a standardized way. Functions are blocks of code that perform a specific task — think of them as the verbs in your product’s technical language.

Understanding these is not about coding. It is about understanding how your product’s capabilities are composed, how data flows through your system, and where dependencies or bottlenecks lie.

This matters in practice because:

• When a user clicks a button, what functions run behind the scenes? What APIs are called? How fast are they? What happens if they fail?
• When you want to integrate with a third-party service — say, a payment gateway like Razorpay or a messaging platform like Twilio — how does that integration work technically?
• When your engineering team says, "This feature requires building a new API endpoint," what does that mean for delivery timelines and testing?
• When you consider scaling, how do APIs and functions affect performance, security, and maintainability?

Without this understanding, you are flying blind.

What is an API? The PM’s definition

An API is a set of rules and protocols that allow one software program to talk to another. It defines how requests are made, what data is sent, and what responses look like.

You can think of an API as a waiter in a restaurant. You (the client) place an order, the waiter (API) takes it to the kitchen (server), and then brings back the dish (response). You don’t need to know how the kitchen cooks the food; you just need to know what to ask for and what you’ll get back.

In the Indian context, many companies build APIs to connect their frontend apps to backend services. For example, Swiggy’s app calls APIs to fetch restaurant menus, place orders, or track delivery status. Flipkart’s mobile app uses APIs to display product details, process payments, and update order history.

APIs come in different types:

For a PM, the key is to understand that an API is a boundary — it defines what your product can do, and how other systems can use your product’s capabilities.

Functions: the building blocks of product behavior

A function is a reusable piece of code that performs a specific operation. Functions can be simple — like formatting a phone number — or complex — like calculating loan eligibility.

Functions are the verbs of your product. They implement the logic behind features.

For example, when a user tries to apply a coupon code on Swiggy, a function validates the code, checks expiry, and calculates discount. When a user uploads a photo on ShareChat, a function processes the image, compresses it, and stores it.

Functions are often exposed via APIs, so an API might call several functions in sequence or in parallel to fulfill a request.

Understanding functions helps you:

• Anticipate where bugs might occur ("If the coupon validation function is slow, users will get frustrated.")
• Plan feature decomposition ("This feature requires three distinct functions: data validation, business logic, and notification.")
• Communicate clearly with engineers about scope and complexity

How APIs and functions shape product design and user experience

Your product’s user experience depends on how well the APIs and functions deliver the expected behavior.

Performance: Slow API responses or inefficient functions lead to laggy interfaces. For instance, a 3-second delay in loading Flipkart’s product page can cause users to abandon the app.

Reliability: If APIs fail silently, users get stuck. Swiggy’s order tracking relies on real-time API calls — if those fail, users see stale or wrong information, eroding trust.

Security: APIs expose your product’s data and actions. Without proper authentication and authorization, users or attackers can exploit vulnerabilities. PhonePe applies strict API security to protect financial transactions.

Scalability: As your user base grows, APIs and functions must handle increased load. Meesho’s backend APIs handle millions of daily requests during sales events — any bottleneck can cause outages.

Integration: APIs enable your product to connect with partners and third-party services. Razorpay’s payment gateway APIs let merchants accept payments seamlessly, expanding Razorpay’s ecosystem.

For PMs, this means that decisions about features often involve API and function trade-offs:

• Should a feature load all data upfront or fetch it on demand via APIs?
• Can some functions be cached or precomputed to speed up UX?
• What is the fallback if an API call fails?
• How do API limits affect your product’s capabilities?

Common pitfalls PMs face with APIs and functions

1. Treating APIs as black boxes

Some PMs think APIs are technical plumbing they don’t need to understand. That is a trap.

If you cannot answer questions like:

• What data does this API return and in what format?
• What are its latency and error rates?
• What are the dependencies and side effects?

you are not ready to scope or prioritize features involving that API.

2. Ignoring API versioning and backward compatibility

APIs evolve. Changes can break existing clients if not managed carefully.

If you ignore versioning, your product risks outages or inconsistent behavior when backend APIs change. Flipkart and PhonePe maintain strict API versioning policies to avoid such issues.

3. Overloading APIs with too much responsibility

Sometimes teams build APIs that do too many things, violating the single responsibility principle. This makes APIs hard to maintain and test.

PMs should encourage clear API boundaries aligned with product capabilities.

4. Underestimating error handling and edge cases

APIs can fail for many reasons — network issues, invalid data, timeouts.

If your product design assumes APIs always succeed, users will face frustrating errors.

5. Overlooking security and privacy implications

APIs expose data. PMs must ensure that APIs enforce proper authentication, authorization, and data masking.

In Indian fintech, regulatory compliance demands audit trails and data protection in APIs.

How to work effectively with engineers on APIs and functions

Your role is to translate user and business needs into technical requirements.

Ask the right questions:

• What APIs exist today that support this feature?
• What new APIs or functions need to be built?
• What are the expected performance SLAs?
• How will failures be handled and surfaced to users?
• What are the security requirements?
• How will we test and monitor these APIs?

Use API documentation as a communication tool.

Encourage engineers to maintain clear API docs with examples, error codes, and version history. This helps cross-functional teams understand capabilities and constraints.

Incorporate API considerations in your product specs and user stories.

Define acceptance criteria that include API behavior — response times, error scenarios, data formats.

Plan for integration testing and end-to-end validation.

APIs connect multiple systems. Ensure your QA plans cover these interactions.

Indian startup examples where APIs and functions matter

• Razorpay: Their entire business model is API-centric. Merchants integrate Razorpay’s payment APIs into websites and apps. The PM must understand API limits, security, and error modes to design reliable payment flows.

• Swiggy: The order lifecycle depends on APIs connecting customers, restaurants, and delivery partners. Functions handle everything from menu rendering to delivery tracking. PMs coordinate with engineering to optimize these APIs for speed and reliability during peak hours.

• Meesho: Their GraphQL APIs enable efficient data fetching for millions of resellers. Functions implement complex pricing, discount, and order fulfillment logic. PMs must balance API complexity with frontend performance.

A PM’s mental model for APIs and functions

Think of your product as a set of layers:

• User interface: What the user sees and interacts with.
• API layer: The contract that connects UI with backend services.
• Function layer: The implementation of business logic and data processing.
• Data layer: Databases and external systems.

Your job is to ensure that the API layer is well-defined, stable, and aligned with user needs, and that functions implement the expected behavior efficiently and correctly.

If you cannot answer how a feature flows through these layers, you are not ready to sign off on delivery.

When to get technical and when to stay high-level

You do not need to write functions or design APIs yourself. But you must:

• Understand enough to evaluate estimates and trade-offs.
• Ask engineers to explain in simple terms how features work under the hood.
• Challenge vague answers like "It’s complicated" — ask for specifics.
• Use diagrams or flowcharts to visualize API calls and function sequences.
• Keep learning the basics of web protocols, data formats (JSON, XML), and common API patterns.

This knowledge builds trust and speeds up decision-making.

Supporting media: Talvinder’s explainer video on APIs and functions

Test yourself: API trade-off scenario

Where to go next

• If you want to deepen your technical fluency as a PM: Technical Fluency for PMs
• If you want to learn how to write effective product requirements: Writing PRDs and User Stories
• If you want to understand API design and microservices: API Design Fundamentals
• If you want to master stakeholder communication around technical trade-offs: Stakeholder Management for PMs
• If you want to explore product management in fintech: Fintech Product Management />