Les anti-patterns microservices que nous voyons dans chaque audit

Microservices can improve scalability and team autonomy. They can also create operational chaos, debugging nightmares, and teams that spend more time on plumbing than product. In our audits we see the same anti-patterns again and again.

Here are the mistakes we flag most often — and what to do instead.

Too many services too soon

Teams split a monolith into 40 services before they have a clear ownership model or operational maturity. The result: no one knows who owns what, deployments become a coordination nightmare, and a single business flow spans 15 services.

Start with a modest number of services — often 3–5 — that map to clear bounded contexts and team boundaries. Add services when you have a concrete reason: a team needs to scale independently, a component has different scaling characteristics, or a technology boundary is justified. Not because "microservices" sounds modern.

Shared databases

The most common and most damaging anti-pattern: multiple services reading and writing the same database. You lose encapsulation, create hidden coupling, and make schema changes a cross-service coordination problem.

Each service should own its data. Communicate via APIs or events, not direct database access. If you're not willing to give a service its own data store, it's not a separate service — it's a module that should live in a larger boundary.

Distributed monolith

Services are deployed separately but change together. A "simple" feature requires code changes in five repos and a coordinated release. You have the operational cost of distribution without the independence benefit.

Avoid this by enforcing strict API contracts and backward compatibility. Services should be deployable in any order. If you can't deploy service A without deploying B, you've built a distributed monolith.

No observability strategy

With one service, logs and a single process tell the story. With 20 services, a single request might touch 8 of them. Without distributed tracing, correlation IDs, and structured logging, debugging is guesswork.

• Implement distributed tracing (e.g. OpenTelemetry) from day one. Every service should propagate trace context.
• Use correlation IDs so you can follow a request across services in logs.
• Define SLOs per service and alert on them. Know which service is slow before users complain.

Synchronous chains

Service A calls B calls C calls D. Latency adds up. A single slow or failing service takes down the whole chain. Prefer asynchronous communication where possible: publish events, let consumers react. Use sync only when the caller genuinely needs an immediate response.

If you must chain synchronously, set timeouts and circuit breakers at every hop. One bad dependency shouldn't cascade.