Should every frontend have its own backend?

Not necessarily.

A frontend does not always need its own dedicated backend, but it often needs some backend or API layer. The right setup depends on the product, team, and scale.

Common patterns

1. Frontend + shared backend

Multiple frontends use one backend service or API.

• Good for: web app + mobile app sharing the same data/model
• Pros: less duplication, simpler data consistency
• Cons: can become tightly coupled, frontend-specific needs may be awkward

2. Frontend + BFF (Backend for Frontend)

Each frontend has a backend tailored to it.

• Example: web app has one BFF, mobile app has another
• Good for: different UI needs, different payload shapes, varying auth/session logic
• Pros: optimized for each client, less frontend complexity
• Cons: more services to maintain, duplicated logic possible

3. Frontend-only with third-party services

The frontend talks directly to managed services like Firebase, Supabase, or GraphQL endpoints.

• Good for: prototypes, small apps, simple products
• Pros: fast to build
• Cons: less control, security and business logic can get messy client-side

When a frontend should have its own backend

A dedicated backend is useful if:

• the frontend needs custom aggregation of multiple services
• you want to hide internal APIs or secrets
• you need server-side business rules
• auth/session handling is complex
• the frontend has performance needs like response shaping, caching, or batching
• different clients need different data formats

When it may not need one

You may not need a dedicated backend if:

• your app is simple
• one shared backend already serves all clients well
• you’re using a backend-as-a-service
• the frontend mostly renders data with little client-specific logic

Practical rule of thumb

• Small/simple app: one shared backend is usually enough
• Multiple clients with different needs: consider a BFF per frontend
• Prototype or solo project: start with the simplest possible backend setup
• Large system: separate frontend-specific backends can improve maintainability

If you want, I can also sketch a few concrete architectures for:

• single web app
• web + mobile
• microservices with a BFF