Course contentsShow
← Cloud and Infrastructure
Lesson 2561 of 2,98955. Microservices on CloudFree lesson

Database per Service Pattern

Isolating data stores per microservice for autonomy and independent schema evolution.

Database per Service Pattern

What you'll learn: How to give each microservice its own dedicated database to maintain autonomy, prevent tight coupling, and enable independent evolution.

Core Idea

The Database per Service Pattern means each microservice owns and manages its own private data store. No other service can access that database directly—only through the service's API. This is the opposite of traditional monolithic architectures where all components share one central database.

Think of it like apartments in a building. Each tenant (microservice) has their own locked apartment (database) with their own furniture arrangement (schema). They don't wander into each other's apartments to borrow things—they knock on the door and ask (use the API).

Why It Matters

When services share a database, they become tightly coupled. If Service A changes a table schema, Service B might break. Deployments must be coordinated. Teams can't work independently.

With separate databases:

  • Schema autonomy: Each service can evolve its data model without coordination
  • Technology choice: Service A can use PostgreSQL while Service B uses MongoDB
  • Independent scaling: Scale databases based on each service's specific needs
  • Failure isolation: A database issue in one service won't cascade to others
  • Team ownership: Clear boundaries mean clear responsibility

Trade-offs

You're trading simplicity for resilience. Cross-service queries become harder—you can't just JOIN across services. You'll need patterns like API composition, event-driven synchronization, or CQRS (which you've learned) to handle distributed data.

Key Takeaway:
The Database per Service pattern enforces loose coupling by giving each microservice exclusive ownership of its data store, enabling independent development, deployment, and scaling at the cost of more complex cross-service data operations.