Why Does One App Need Multiple Backends
The backend-for-frontend pattern explained: why a web client, a mobile app and a smart TV are better served by different backends than one shared API.
- System Design Explained
- Backend for Frontend
- Frontend Architecture
- System Design
- Software Architecture
Imagine you're building an e-commerce platform. You have: π± A mobile app π» A web application β A smartwatch app
All three need the same customer data. So should they all call the same backend APIs?
At first, that sounds reasonable. Until reality gets in the way. The web application needs detailed product information. The mobile app needs smaller payloads to reduce network usage. The smartwatch only needs order status.

If every client consumes the same APIs, one of two things usually happens:
- Clients receive far more data than they need.
- Or backend APIs become increasingly difficult to evolve without breaking someone.
That's where the Backend for Frontend (BFF) pattern comes in. Instead of one generic backend serving everyone, each client gets a backend tailored to its needs.
- Mobile BFF
- Smaller payloads
- Optimized for slower networks
- Web BFF
- Richer data
- Aggregates multiple services into a single response
- Wearable BFF
- Minimal data
- Battery-conscious responses
One thing I like about this pattern is that it optimizes for teams as much as technology. Frontend teams can evolve their APIs independently. Backend services stay focused on business capabilities. Clients receive exactly what they need.
It's a good reminder that architecture isn't always about adding complexity. Sometimes it's about moving complexity to the right place.
Keep reading
How Does Instagram Build Your Feed in Seconds?
Instagram does not build your feed when you open the app. How precomputation, fan-out and caching turn an expensive query into an instant scroll.
Your Frontend Shouldn't Trust a Single Click
Disabling the button is not enough. Why duplicate-submission protection has to exist on the client and the server, and what each layer is responsible for.
How Does Stripe Avoid Charging You Twice?
Stripe's idempotency keys explained β how a payment API safely handles the same request arriving more than once without charging the customer twice.