High cohesion in Microservices - Scalability & System Analysis

Scalability Analysis - High cohesion

Growth Table: High Cohesion in Microservices

Users/Scale	100 Users	10K Users	1M Users	100M Users
Service Count	Few (3-5)	10-20	50-100	Hundreds+
Service Size	Small, focused	Small, focused	Small, focused	Small, focused
Inter-service Calls	Low	Moderate	High	Very High
Data Ownership	Clear per service	Clear per service	Clear per service	Clear per service
Deployment Frequency	Low	Moderate	High	Very High
Complexity	Low	Moderate	High	Very High

First Bottleneck

At small scale, the first bottleneck is usually the database because each microservice owns its data and queries increase with users.

As users grow, inter-service communication becomes the bottleneck due to many small services calling each other, causing latency and network overhead.

Without high cohesion, services may have overlapping responsibilities, increasing coupling and making scaling harder.

Scaling Solutions for High Cohesion

• Maintain small, focused services: Each service handles a single responsibility to reduce complexity and improve scalability.
• Database per service: Avoid shared databases to reduce contention and allow independent scaling.
• Use asynchronous communication: Message queues or event-driven patterns reduce tight coupling and improve resilience.
• API Gateway and service mesh: Manage inter-service calls efficiently and monitor traffic.
• Horizontal scaling: Add more instances of services independently based on load.
• Cache frequently accessed data: Reduce database load and improve response times.
• Automate deployments: Continuous integration and delivery help manage many small services.

Back-of-Envelope Cost Analysis

Assuming 1M users generating 100 requests per second (RPS) total:

• Each microservice handles ~100-1000 RPS depending on responsibility.
• Database instances per service handle ~5000 QPS; scaling needed if exceeded.
• Network bandwidth depends on payload size; 1 Gbps (~125 MB/s) supports many small calls.
• Storage grows with data owned by each service; archiving old data reduces cost.

Interview Tip

When discussing high cohesion in microservices, start by explaining the importance of single responsibility per service.

Describe how this reduces complexity and improves scalability.

Then, discuss bottlenecks like database load and inter-service communication.

Finally, explain scaling solutions like asynchronous messaging, caching, and horizontal scaling.

Self Check Question

Your database handles 1000 QPS. Traffic grows 10x. What do you do first?

Answer: Add read replicas and implement caching to reduce database load before scaling vertically or sharding.

Key Result

High cohesion in microservices keeps services small and focused, which helps scale independently. The first bottleneck is usually the database or inter-service communication as users grow. Solutions include database per service, asynchronous messaging, caching, and horizontal scaling.