The technology choices behind Netflix, Uber, WhatsApp, Instagram, Spotify and Airbnb reveal something the framework debates on social media rarely admit: there is no universally “best” stack. There is only the right stack for a specific problem, at a specific scale, with a specific team. Here is what each of these companies actually runs on — and the lesson behind each choice.

Netflix: Java, Cassandra and a Custom-Built CDN

Netflix serves over 300 million subscribers across 190 countries and is responsible for a significant share of global downstream internet traffic. Its technology choices reflect the scale of that challenge.

The frontend runs on React, with GraphQL (via Netflix’s open-source DGS framework) handling data fetching for most modern client surfaces, after years of relying on a custom system called Falcor. The backend is built predominantly in Java with Spring Boot, powering thousands of independently deployable microservices. Python and Go handle specific domains including machine learning and observability tooling.

For data storage, Netflix relies on Apache Cassandra as its primary scale-out NoSQL store, EVCache (a memcached-based system) for high-speed caching, and MySQL for transactional data like billing. Real-time data movement runs through Kafka and Netflix’s own streaming platforms, Mantis and Keystone.

Perhaps the most striking architectural decision is Open Connect — Netflix’s proprietary content delivery network. Rather than relying entirely on third-party CDNs, Netflix places its own caching servers directly inside internet service provider networks around the world, pushing content as close to viewers as possible during off-peak hours.

The lesson: when you operate at a scale where standard infrastructure no longer fits your problem, building proprietary infrastructure becomes the rational choice — not over-engineering.

Uber: Polyglot Microservices Built for Real-Time Geography

Uber’s engineering challenge is fundamentally about real-time coordination across location, time and millions of simultaneous transactions. The company’s technology stack reflects a deliberate move away from a single dominant language toward a polyglot microservices architecture.

Uber’s backend spans Go, Java and Node.js, chosen for different services based on performance requirements and team expertise. The company famously built its own database system, internally known as Schemaless, on top of MySQL to handle the specific consistency and scale requirements of ride data. PostgreSQL and MySQL both appear throughout the broader system for different workloads. Kafka handles the real-time event streaming that powers live trip tracking, surge pricing calculations and driver-rider matching.

Uber migrated from an early monolithic architecture to microservices specifically because a single application could not be scaled, deployed and maintained fast enough to support the company’s growth. This migration was not undertaken on day one — it happened in response to genuine scaling pressure.

The lesson: architecture should follow the shape of your actual problem. Uber’s real-time, geographically distributed coordination problem demanded an architecture that could evolve service by service, rather than a single codebase trying to do everything.

WhatsApp: Erlang and the Power of the “Boring” Choice

WhatsApp’s technology story is one of the most instructive in the industry. At the time of its acquisition by Facebook in 2014, WhatsApp was famously serving hundreds of millions of users with an engineering team that numbered only in the dozens.

The reason this was possible comes down largely to one technology choice: Erlang. Erlang is a programming language originally built by Ericsson for telecommunications systems — designed from the ground up to handle massive numbers of concurrent, lightweight connections with extremely high reliability. It is not a trendy language. It was never going to top a “hottest frameworks of the year” list. But it was exactly suited to WhatsApp’s core problem: keeping millions of persistent connections open simultaneously, reliably, with minimal overhead.

The lesson: the most-discussed technology is rarely the most appropriate one. WhatsApp chose a niche, decades-old language because it was the correct tool for the specific problem — and that choice let a tiny team support an enormous user base.

Instagram: Scaling to a Billion Users on Python

Instagram is frequently cited as proof that the programming language you choose matters far less than how you architect around it. The platform’s backend is built primarily in Python using the Django framework — a combination often dismissed as too slow for applications at serious scale.

Instagram has scaled past a billion users on this foundation. The data layer relies on PostgreSQL for core relational data and Cassandra for specific high-volume, high-availability workloads. Caching is handled through Memcached and Redis, which absorb the read load that would otherwise hit the database directly for every request.

What made this scale possible was not a language switch but disciplined engineering around the language: aggressive caching strategies, careful database sharding, asynchronous processing for non-critical paths, and a willingness to optimise the specific bottlenecks that actually appeared under real load rather than guessing in advance.

The lesson: a programming language’s raw performance characteristics matter far less at scale than the architecture built around it. Bad architecture will make a fast language slow. Good architecture can make a famously “slow” language scale to a billion users.

Spotify: Microservices and the Squad Model

Spotify’s technology stack centres on Java and Python across a large number of independently owned microservices, with Google Cloud Platform and BigQuery handling much of its data infrastructure, and Kafka powering real-time event streaming for everything from play counts to recommendation signals.

What makes Spotify particularly interesting is not just the technology but the organisational model built around it. Spotify popularised the “squad” model — small, autonomous, cross-functional teams that each own a specific service or feature area end to end, with the freedom to choose their own tools and deployment cadence within broad guardrails.

This organisational structure and the underlying microservices architecture reinforce each other. Independent services map naturally onto independent teams, allowing Spotify to ship changes across a vast product surface without every team needing to coordinate on every release.

The lesson: technical architecture and organisational structure are deeply connected. The way you split your codebase into services often ends up mirroring — or should mirror — the way you split your teams. This is sometimes called Conway’s Law, and Spotify is one of its most-cited modern examples.

Airbnb: Starting on Rails, Evolving Under Scale

Airbnb’s technology story is a useful counterpoint to the others on this list because it illustrates evolution rather than a single static stack. The platform was originally built on Ruby on Rails — a framework chosen specifically for the speed at which it allowed a small founding team to build, iterate and ship a working product.

As Airbnb scaled into a global marketplace processing complex search, pricing and trust-and-safety logic, the company began migrating performance-critical and team-isolated portions of its system toward service-oriented architectures using languages including Java and Kotlin, while React became the standard for frontend development. MySQL and Redis remain core to the data layer.

Airbnb did not rewrite everything overnight, and it did not start with a microservices architecture from day one. The migration happened gradually, driven by specific scaling pain points rather than a wholesale rejection of the original technology choice.

The lesson: starting with a framework optimised for development speed is often the correct early-stage decision, even if it is not the architecture you will run at massive scale. Re-architecting in response to real growth is normal and expected — it is not a sign that the original choice was wrong.

What These Six Stacks Teach Every Founder and CTO

Looking across all six companies, four patterns emerge that matter far more than any individual technology choice.

There is no universally best stack. Java works for Netflix and Spotify. Python works for Instagram. Erlang works for WhatsApp. Ruby on Rails worked for early Airbnb. Each choice was correct for the problem, team and stage it was made for — not because of any inherent superiority of the language itself.

Boring, proven technology beats trendy technology at scale. None of these companies built their core infrastructure on whatever was generating the most hype on social media at the time. Cassandra, MySQL, Kafka and PostgreSQL are not exciting choices. They are reliable ones, with deep operational knowledge available across the industry.

Architecture matters more than the language itself. Instagram on Python and WhatsApp on Erlang both scaled to enormous user bases despite using technologies that are, by raw benchmark numbers, far from the fastest options available. The architecture built around the language — caching strategy, database design, service boundaries — determined the outcome far more than the language choice alone.

Start simple and re-architect when growth demands it. Airbnb did not start with a complex microservices architecture. WhatsApp did not start by trying to anticipate Facebook-scale traffic. Every one of these companies built something that worked for their actual stage, then evolved the architecture as real scaling pressure emerged — not in anticipation of hypothetical future scale.

How Onclick Innovations Approaches Technology Decisions

At Onclick Innovations, we do not have a default stack we push onto every client regardless of fit. We have built production applications in React, Vue and Angular for the frontend, and Node.js, Python, PHP and Java for the backend — choosing based on the specific project, team, timeline and long-term maintenance considerations involved.

The pattern across the six companies in this article holds true for every project we work on, regardless of size: the right technology choice is the one that fits the actual problem you are solving today, with room to evolve as your product and user base grow. Not the most fashionable choice. Not the one with the most active hype on social media this month. The right one for your specific situation.

If you are making technology decisions for a new product, or reconsidering the architecture behind an existing one, we are happy to talk through the tradeoffs honestly.

📩 Get in touch → www.onclickinnovations.com
📍 Based in Mohali, India · Serving clients globally across 10+ countries

Frequently Asked Questions

What programming language does Netflix use?

Netflix uses Java with Spring Boot as the primary language for its backend microservices, React for its frontend, and Python and Go for specific domains like machine learning and observability. Its data layer relies on Apache Cassandra, EVCache and MySQL, with Kafka handling real-time event streaming.

Why does WhatsApp use Erlang?

WhatsApp chose Erlang because it was specifically designed for telecommunications systems that need to handle massive numbers of concurrent, lightweight connections with high reliability and minimal overhead. This made it exceptionally well suited to WhatsApp’s core technical challenge of maintaining millions of simultaneous persistent connections, allowing a small engineering team to support an enormous global user base.

How did Instagram scale to a billion users on Python?

Instagram scaled on Python and Django through disciplined architecture rather than raw language performance: aggressive caching with Memcached and Redis, careful database sharding across PostgreSQL and Cassandra, and asynchronous processing for non-critical operations. This demonstrates that architectural decisions around a language matter more than the language’s raw benchmark speed.

Should a startup choose the same tech stack as a company like Netflix or Uber?

No. The technology choices made by Netflix, Uber and similar companies were shaped by their specific scale, team size and problem domain at the time those decisions were made — often after years of evolution from much simpler starting points. A startup should choose technology that fits its current stage, team expertise and actual requirements, with an architecture that can evolve as real growth demands it, rather than copying the infrastructure of a company operating at a vastly different scale.

Can Onclick Innovations help us choose the right technology stack for our product?

Yes. We help clients evaluate technology decisions based on their specific project requirements, team composition, timeline and growth plans rather than defaulting to a single preferred stack. Contact us at onclickinnovations.com to discuss your project.

Share

The post The Tech Stack Behind 6 Famous Apps: What Netflix, Uber, WhatsApp, Instagram, Spotify and Airbnb Are Actually Built With appeared first on Blog.

Nobody tweets that checkout was seamless. Nobody calls support to say everything worked perfectly. Nobody posts a five-star review of the payment gateway because it processed their transaction in 180 milliseconds without a single hiccup.

The silence is the success.

This is the central paradox of great software engineering — and it is one that most people outside of engineering never fully grasp. The best software is invisible. Users never notice it working. They only notice when it breaks.

The Invisible Software Running the World Right Now

Before we talk about what invisible software looks like in practice, consider the scale at which it already operates around you.

Air traffic control software coordinates approximately 45,000 flights every single day. When was the last time you thought about the software keeping those planes separated? You haven’t. Because it works. The moment it stops working — a single incident in 2023 grounded thousands of US flights when a safety database file corrupted — it becomes the only thing anyone talks about.

Payment rails process over $500 trillion in transactions every year. The entire global economy moves through software that most people cannot name and have never thought about. When your card is declined because of a processing error, you notice immediately. When it processes in 180 milliseconds as it has ten thousand times before, you do not notice at all.

Traffic light systems operate in cities used by over four billion people daily. The timing algorithms that prevent gridlock and reduce accidents run continuously, invisibly, without acknowledgement. When a traffic light fails and an intersection grinds to a halt, it makes local news. When it works, it is furniture.

The scroll on your iPhone was engineered by a team that spent months ensuring it responds to exactly 60 frames per second — the threshold at which human perception stops distinguishing software from physics. You do not think “this scroll feels good.” You think “this phone feels good.” The engineering disappears into the experience.

This is what invisible software looks like at scale. And it is the standard that every piece of software should aspire to.

What Makes Software Invisible

Invisible software is not the result of clever code. Clever code gets noticed — usually by the developer who inherits it, at 2am, during a production incident they cannot diagnose because the original author was too clever to write comments.

It is not the result of impressive architecture. Nobody using Uber cares about their microservices topology. Nobody using Notion cares about their block-based data model. They care that the product works the way they expect it to work, every time they use it.

It is not beautiful design alone. A stunning interface that takes six seconds to load on a standard mobile connection is not invisible — it is conspicuous. Every user who watches a spinner is noticing your software in the worst possible way.

Invisible software is the result of something less glamorous and more demanding than any of these things:

Obsessive Attention to Edge Cases

The scenarios nobody thought to test are always the ones that surface in production. The user who pastes a 10,000-character string into a name field. The customer who submits a form by pressing Enter twice in rapid succession. The API client that retries a failed request without an idempotency key and creates duplicate records. The database query that performs beautifully on 10,000 rows and catastrophically on 10,000,000.

Invisible software handles these cases gracefully, silently, and without the user ever knowing they triggered an edge condition at all.

Performance Work That Makes Fast Feel Instantaneous

There is a threshold in human perception below which speed stops being a feature and becomes physics. Below about 100 milliseconds, a response feels immediate. Below 60 frames per second in animation, motion feels mechanical rather than natural. Below the threshold of noticeability, software becomes part of the environment.

The performance work that pushes software below these thresholds is some of the most demanding and least celebrated engineering that exists. It requires deep knowledge of how browsers render, how databases execute query plans, how networks introduce latency, and how human perception works. It produces software that people describe as “feeling right” without being able to say why.

Error Handling So Graceful Users Never See Errors

Every system fails. The question is whether the failure is visible to the user or invisible to them. Invisible software anticipates failures and handles them before they surface. A failed API call is retried with exponential backoff. A slow database query returns cached data with a freshness indicator. A third-party service going down triggers a circuit breaker that serves a degraded but functional experience rather than an error page.

Users experiencing invisible error handling do not know anything went wrong. They experience a slightly slower response, or a cached result, or a simplified interface. They do not experience a 500 error, a blank screen, or a lost form submission.

Infrastructure That Scales Before It Needs To

The viral moment, the press mention, the unexpected traffic spike from a social media post — these events do not announce themselves in advance. Invisible software is built for the traffic it does not yet have, so that when the traffic arrives, nobody notices the transition. The load balancers scale. The database read replicas absorb the increase. The CDN serves the static assets from edge locations near each user. The experience remains exactly the same at ten users and ten thousand.

Teams That Celebrate Zero Incidents

Perhaps the most important ingredient in invisible software is cultural rather than technical. Teams that treat a quiet week as a success — that celebrate the absence of incidents rather than only acknowledging heroic responses to them — build differently than teams that treat firefighting as the norm.

The heroic engineer who stays up all night fixing a production crisis is visible and celebrated. The methodical engineer who prevents the crisis from occurring through careful design, thorough testing, and comprehensive monitoring is invisible. Their best work is the absence of a story.

The Paradox of Great Engineering

This creates a genuine paradox for engineering teams and the businesses that employ them. The easiest engineering work to see and celebrate is the work done in response to failure. The hardest work to see and celebrate is the work that prevents failure.

Your best work is the work nobody ever talks about.

Your worst work is the work everybody is talking about.

This paradox shows up in how engineering teams are evaluated, how software projects are estimated, and how technical decisions get made under pressure. The features that users can see and comment on get prioritised. The reliability work that keeps those features working invisibly gets treated as optional, deferrable, something to address in a future sprint that never arrives.

The result is software that is visible in all the wrong ways. The loading spinner. The error message. The lost form submission. The 3am incident that interrupts someone’s weekend. The rollback that takes a feature users depend on offline for four hours.

“The goal of great engineering is not to be noticed. The goal is to be trusted.”

Measuring Success by What Does Not Happen

At Onclick Innovations, we have spent over a decade building software across fintech, healthcare, e-commerce, logistics and enterprise SaaS. 350+ products shipped. Clients across 10+ countries.

The metric we pay most attention to is not the one most clients ask about first. It is not features delivered per sprint, or velocity, or lines of code, or even uptime percentage.

It is this: what did not happen.

No 3am incidents. No rollbacks. No “it worked on staging.” No “we’ll fix it in the next sprint” carrying over for three quarters. No “the database went down because of a query we didn’t optimise.” No “we lost data because we didn’t account for that edge case.”

The absence of these events is the product of the engineering choices made before any code is written. The architecture review that catches the single point of failure before it becomes a production incident. The load test that surfaces the database query that performs fine at 1,000 records and destroys performance at 1,000,000. The error handling design that ensures a third-party service going down does not take the entire application with it.

This work is invisible by design. And that invisibility is the measure of its success.

What This Means for Businesses Building Software

If you are building a software product — whether it is a customer-facing application, an internal tool, or the infrastructure that runs your business — the most important question you can ask your engineering team is not “what are we building next?”

It is “what are we preventing?”

The most powerful thing you can build is software that people forget exists. Not because it is unimportant — but because it works so reliably, so quietly, so consistently, that it becomes part of the environment. It becomes infrastructure. It becomes the thing your business runs on without thinking about it.

That is the goal. Not to be noticed. To be trusted.

The software that achieves this is not built by accident. It is built by teams that have internalised the paradox of great engineering — that the work most worth doing is often the work that, if done correctly, nobody will ever see.

How Onclick Innovations Builds Invisible Software

Every product we build at Onclick Innovations is designed to be invisible in the ways that matter.

We build error handling before we build features. We load test before we go to production. We design for the traffic we do not yet have. We write the monitoring that catches problems before users do. We build the retry logic that handles the failed API call the user never sees. We design the database schema for the query patterns that will matter at scale, not just the patterns that matter today.

We celebrate quiet weeks. We treat an absence of incidents as the measure of a week well spent. We build software that people forget exists — because they are too busy using it to build their business.

📩 Get in touch → www.onclickinnovations.com
📍 Based in Mohali, India · Serving clients globally across 10+ countries

Frequently Asked Questions

What does “invisible software” mean?

Invisible software refers to software that works so reliably and seamlessly that users never consciously notice it. They only become aware of it when it fails. The concept captures the highest standard of software engineering — not impressive features, but flawless, unnoticed reliability.

Why do users only notice software when it breaks?

Human attention is naturally drawn to anomalies and disruptions. When software works as expected, it becomes part of the background — like electricity or running water. When it fails, it immediately becomes foreground. This is why great software engineering focuses as much on preventing failure as on building features.

What are examples of invisible software?

Air traffic control systems coordinating 45,000 daily flights, payment rails processing $500 trillion annually, traffic light timing algorithms operating in cities used by billions, and the 60fps scroll on modern smartphones are all examples of invisible software — engineering so reliable it disappears into the experience.

How does Onclick Innovations build reliable software?

We build error handling before features, load test before production, design for future scale from day one, implement monitoring that catches problems before users encounter them, and measure success by the absence of incidents as much as by the presence of delivered features. Contact us at onclickinnovations.com to discuss your project.

What is the difference between good software and great software?

Good software does what it is supposed to do. Great software does what it is supposed to do so reliably that users stop thinking about it entirely. The difference lies in the engineering decisions that happen before, during and after feature development — the edge case handling, the performance work, the error design, the monitoring, and the cultural commitment to preventing failure rather than just responding to it.

Share

The post The Best Software Is Invisible: What Great Engineering Actually Looks Like appeared first on Blog.

Published by Onclick Innovations · Software Development · June 2026 · 8 min read

A well-designed API is invisible. Developers consume it, build on top of it, and ship products faster because of it — without ever thinking about the API itself. A poorly designed API is the opposite. It generates support tickets, causes production incidents, and eventually gets rewritten by the team inheriting it.

After building over 350 production software products across fintech, healthcare, e-commerce and enterprise SaaS, we have seen what separates APIs that scale gracefully from APIs that become someone else’s most expensive maintenance problem.

This is the checklist we use internally at Onclick Innovations. Save it. Share it. Use it.

1. Versioning From Day One

Every API should be versioned from the first line of code. Not from the moment you need to make a breaking change — from day one.

The correct pattern is simple: /api/v1/users not /api/users. When you need to introduce a breaking change, /api/v2/ exists without disrupting any client currently integrated against /api/v1/.

Teams that skip versioning always face the same moment: the first time they need to change a response structure, they discover they cannot do it without breaking every client integration simultaneously. At that point the cost of adding versioning retroactively is significantly higher than it would have been from the start.

Versioning is the most important decision you make when designing an API. Everything else is recoverable. Versioning is not.

2. Consistent, Structured Error Responses

Every error your API returns should follow the same structure. Every single one. Without exception.

A well-structured error response contains at minimum:

• An HTTP status code that accurately reflects what happened
• A machine-readable error code (e.g. USER_NOT_FOUND, INVALID_EMAIL_FORMAT)
• A human-readable message that explains what went wrong
• A unique request ID for debugging and support correlation

What a bad API returns: 500 Internal Server Error with no body, or a generic message that gives the consuming developer no actionable information.

Consistent error responses are not just a developer experience concern. They directly reduce your support overhead. When every error contains a request ID, your support team can trace any reported issue in seconds instead of hours.

3. Rate Limiting on Every Endpoint

An API without rate limiting is one script away from being taken offline. Whether the cause is a well-intentioned developer running a loop, a misconfigured client retrying infinitely, or a deliberate attack — the result is the same: your API goes down for everyone.

Implement per-user and per-endpoint rate limits. When a limit is exceeded, return 429 Too Many Requests with a Retry-After header telling the client exactly when they can try again.

Good rate limiting strategy includes different tiers for different endpoint types. A read endpoint can be more generous than a write endpoint. A search endpoint with expensive database operations needs tighter limits than a simple lookup. Apply limits intentionally, not uniformly.

4. Authentication Done Right

There are three authentication patterns that cover the vast majority of API use cases in 2026:

• JWT (JSON Web Tokens) — for stateless authentication where the server does not need to store session state. Ideal for microservices and distributed systems.
• OAuth 2.0 — for third-party integrations where users grant your API access to resources in another system. The correct choice for any social login or third-party service integration.
• API Keys — for server-to-server communication where a trusted system is calling your API directly. Simple, auditable and effective for this specific use case.

The rule that matters most: never roll your own authentication. Cryptographic implementations have subtle edge cases that are extremely difficult to get right and catastrophic when you get wrong. Use established libraries and protocols. The cost of a security vulnerability in authentication code vastly exceeds the cost of using a well-maintained library.

5. Pagination on Every List Endpoint

No list endpoint should ever return an unbounded result set. Every endpoint that returns multiple records needs pagination implemented before it goes to production.

The two common approaches are offset-based pagination (?page=2&limit=20) and cursor-based pagination (?cursor=eyJ1c2VySWQiOjEwMH0). For most production use cases, cursor-based pagination is the superior choice. It performs consistently regardless of dataset size, handles records being added or deleted between pages correctly, and does not degrade as users page deeper into results.

Offset-based pagination is simpler to implement but degrades at scale. When a user requests page 500 of a 10,000-record dataset, the database must skip 9,980 records before returning 20. Cursor-based pagination retrieves only the records that need to be returned, regardless of position.

6. Idempotency Keys for Mutating Operations

Any endpoint that creates a resource, initiates a transaction or triggers an irreversible action should accept an idempotency key.

An idempotency key is a unique identifier sent by the client with their request. If the same request is submitted twice with the same idempotency key — due to a network timeout, a retry logic bug, or a double-click — the server returns the result of the first request instead of performing the operation twice.

This pattern is used by Stripe for every payment operation. It is used by every financial services API that handles money movement. It is the correct default for any operation that should not be duplicated.

Without idempotency keys, a client that retries a failed request due to a timeout may create duplicate records, charge a customer twice, or trigger duplicate notifications. The cost of implementing idempotency keys is small. The cost of not implementing them is measured in production incidents and customer complaints.

7. Request Validation With Specific Error Messages

Validate all input at the API layer before it touches your database or business logic. This means checking types, formats, required fields, value ranges and cross-field constraints.

When validation fails, return exactly what failed and why. Not 400 Bad Request. Not "Invalid input". Something like:

{"field": "email", "error": "INVALID_FORMAT", "message": "The email address provided is not a valid format."}

Specific validation errors eliminate entire categories of back-and-forth between developers integrating your API and your support team. They also reduce incorrect data reaching your database, which prevents a much larger class of downstream problems.

8. Comprehensive Documentation

If a developer needs to read your source code to understand how to use your API, your API has failed. Full stop.

Great API documentation includes:

• An OpenAPI or Swagger specification that is always up to date and generated from the code itself
• A working example for every single endpoint
• Authentication setup instructions that a developer can follow without prior context
• A clear explanation of every error code the API can return
• A changelog that documents what changed between versions and why

Documentation that is maintained separately from the codebase goes out of date. The correct approach is to generate documentation automatically from the code — tools like Swagger UI, Redoc and Stoplight all support this pattern. When the code changes, the documentation changes with it.

9. Logging and Observability

You cannot debug what you cannot see. Every API request should produce a structured log entry containing at minimum: timestamp, user or API key identifier, endpoint called, HTTP method, response status code, response time in milliseconds, and the request ID that appears in any error responses.

Beyond basic logging, production APIs need distributed tracing for requests that span multiple services, metrics on response time percentiles (p50, p95, p99 — not just averages), and alerting on error rate thresholds.

The teams that build observability in from the start spend dramatically less time debugging production incidents. The teams that treat it as something to add later find themselves flying blind at the worst possible moment.

10. Graceful Degradation

In a distributed system, dependencies fail. Third-party services go down. Databases become temporarily unavailable. Internal microservices return unexpected errors.

A well-designed API handles these failures gracefully. When a non-critical dependency fails, the API returns a partial response rather than a complete failure. When a cache is unavailable, the API falls back to the database with a performance warning rather than returning an error. When a downstream service is degraded, the API returns cached data with a staleness indicator rather than a 500.

The pattern to implement is the circuit breaker: monitor failure rates on dependencies, and when they exceed a threshold, stop sending requests to the failing service temporarily and return a cached or degraded response instead. This prevents one failing service from cascading into a complete system outage.

Graceful degradation is the difference between an incident that users notice and an incident that your monitoring catches before users do.

The Pattern Behind Every Item on This List

Every item on this checklist follows the same logic: the cost of implementing it correctly from the start is small, and the cost of not implementing it is paid repeatedly and unpredictably over the lifetime of the API.

The APIs we have inherited that had none of these things always came with the same story: “We built it fast and planned to fix it later.”

Later never comes. Instead, the team inheriting the API spends six months firefighting rather than building new features. The product stagnates. The technical debt compounds. Eventually someone makes the case for a full rewrite — at ten times the cost of building it correctly the first time.

“Fixing a bad API costs 5× more than building a good one. We have seen this enough times to know it is not an exaggeration.”

How Onclick Innovations Builds APIs

Every API we build at Onclick Innovations ships with all ten of these properties as a baseline. Not as extras. Not as a premium tier. As the standard.

Versioning is designed into the routing from the first commit. Error responses follow a consistent schema defined at project kickoff. Rate limiting is configured before the first endpoint goes to production. Authentication uses established protocols, not custom implementations. Documentation is generated automatically from the OpenAPI spec and kept in sync with the codebase.

We have built APIs for fintech platforms handling millions of transactions, healthcare systems managing sensitive patient data, e-commerce platforms processing high-volume order flows, and enterprise SaaS products serving thousands of concurrent users across multiple regions.

The pattern is consistent across all of them: APIs built with these ten properties require dramatically less maintenance, generate fewer support escalations, and support faster feature development than APIs that treat these properties as optional.

📩 Get in touch → www.onclickinnovations.com
📍 Based in Mohali, India · Serving clients globally across 10+ countries

Frequently Asked Questions

What is API versioning and why does it matter?

API versioning is the practice of including a version identifier in your API’s URL structure (e.g. /api/v1/) so that breaking changes can be introduced in a new version without disrupting existing client integrations. It matters because APIs, once consumed by external clients, become contracts. Without versioning, any breaking change breaks every client simultaneously.

What is an idempotency key in API design?

An idempotency key is a unique identifier sent by a client with a mutating API request. If the same request is submitted multiple times with the same idempotency key, the server returns the result of the first successful request rather than performing the operation again. This prevents duplicate records, double charges and duplicate notifications caused by network timeouts and retry logic.

What is the difference between offset and cursor-based pagination?

Offset pagination uses a page number and page size to determine which records to return (e.g. skip 40, take 20). Cursor-based pagination uses a pointer to the last record seen to determine the next page. Cursor-based pagination performs consistently at scale and handles records being added or deleted between pages correctly, making it the preferred approach for production APIs with large datasets.

What authentication method should my API use?

The right authentication method depends on your use case. Use JWT for stateless authentication in single-service or microservices architectures. Use OAuth 2.0 when users need to grant your API access to resources in a third-party system. Use API keys for server-to-server communication. Never implement custom cryptographic authentication — use established libraries and protocols.

How does Onclick Innovations approach API design?

We build all ten of these properties into every API from day one as a baseline standard. We use OpenAPI specifications to keep documentation in sync with the codebase automatically, implement cursor-based pagination on all list endpoints, and use established authentication protocols across all integrations. Contact us at onclickinnovations.com to discuss your API requirements.

Share

The post API Design Checklist: 10 Things Every Great API Has appeared first on Blog.