When to use microservices (and when not to) - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identifying when microservices add value

Which scenario best justifies adopting a microservices architecture?

A A small startup with a simple app and a single development team.

B A static website with minimal backend logic and low traffic.

C A large e-commerce platform with multiple teams working on different features independently.

D A batch processing script that runs once a day without user interaction.

💡 Hint

Think about when splitting into smaller services helps manage complexity and team independence.

Microservices are most beneficial when multiple teams work independently on different parts of a large system, allowing for better scalability and deployment flexibility.

❓ tradeoff

intermediate

Tradeoffs of microservices in small projects

What is a common downside of using microservices for a small, simple project?

A Better team autonomy and faster deployments.

B Improved fault isolation and easier scaling.

C Automatic performance improvements without extra effort.

D Increased complexity and overhead in managing multiple services.

💡 Hint

Consider the management effort required for multiple services versus a single app.

For small projects, microservices add complexity and operational overhead that may not be justified by the benefits.

❓ Architecture

advanced

Choosing architecture for a growing application

A company has a monolithic app that is growing rapidly. Which architectural change best supports scaling development and deployment?

A Keep the monolith and add more servers to handle load.

B Split the app into microservices based on business capabilities.

C Rewrite the entire app in a new programming language.

D Use a single database for all features to simplify data management.

💡 Hint

Think about how to enable teams to work independently and deploy features separately.

Splitting into microservices by business capabilities allows independent scaling, deployment, and development, which suits a rapidly growing app.

❓ scaling

advanced

Scaling challenges with microservices

What is a common challenge when scaling microservices that does not typically occur in monolithic apps?

A Managing distributed data consistency across services.

B Adding more CPU and memory to a single server.

C Writing code in a single programming language.

D Deploying the entire app as one unit.

💡 Hint

Consider what happens when data is spread across multiple independent services.

Microservices often require complex strategies to keep data consistent across services, unlike monoliths where data is centralized.

❓ estimation

expert

Estimating operational overhead of microservices

A company plans to migrate from a monolith to 20 microservices. Which factor most increases operational overhead?

A The need to monitor and log each service separately.

B Writing all services in the same programming language.

C Deploying all services together as a single package.

D Using a single shared database for all services.

💡 Hint

Think about what multiplies as the number of services grows.

Each microservice requires its own monitoring, logging, and alerting setup, increasing operational complexity significantly.

Practice

1. Which scenario is best suited for using microservices architecture?

easy

A. A large, complex application requiring independent scaling of components

B. A simple, single-function app with a small user base

C. A small script running on a single machine

D. A static website with no backend logic

Solution

1. Step 1: Understand microservices purpose

   Microservices are designed for complex apps where parts can scale or update independently.

2. Step 2: Match scenario to microservices benefits

   A large app needing flexibility and scaling fits microservices well; small or simple apps do not.

3. Final Answer:

   A large, complex application requiring independent scaling of components -> Option A

4. Quick Check:

   Complex app = microservices [OK]

Hint: Use microservices only for complex, scalable apps [OK]

Common Mistakes:

• Choosing microservices for small or simple apps
• Ignoring team size and management overhead
• Assuming microservices always improve performance

2. Which of the following is a correct reason NOT to use microservices?

easy

A. The app requires frequent updates to parts

B. The application is very small and simple

C. The app needs to scale independently

D. The app has multiple teams working on different features

Solution

1. Step 1: Identify when microservices are unnecessary

   Microservices add complexity and overhead, so small simple apps don't benefit.

2. Step 2: Evaluate options

   Options A, B, and D are reasons to use microservices, not avoid them.

3. Final Answer:

   The application is very small and simple -> Option B

4. Quick Check:

   Small app = avoid microservices [OK]

Hint: Avoid microservices for small, simple apps [OK]

Common Mistakes:

• Confusing scaling needs as a reason to avoid microservices
• Ignoring complexity added by microservices
• Assuming microservices fit all team sizes

3. Consider a microservices app with 5 services. If each service requires 2 developers and the team has only 6 developers total, what is the likely outcome?

medium

A. The team can easily manage all services independently

B. The services will merge into a monolith automatically

C. The team will struggle due to insufficient resources for each service

D. The app will automatically scale without developer input

Solution

1. Step 1: Calculate developer needs

   5 services x 2 developers each = 10 developers needed.

2. Step 2: Compare with available team size

   Only 6 developers are available, which is less than 10, causing resource strain.

3. Final Answer:

   The team will struggle due to insufficient resources for each service -> Option C

4. Quick Check:

   Dev shortage = struggle managing microservices [OK]

Hint: Check if team size matches microservices needs [OK]

Common Mistakes:

• Assuming microservices scale developer needs automatically
• Ignoring team size constraints
• Thinking services merge automatically without effort

4. A team tries to convert a small monolithic app into microservices but faces deployment failures and communication errors. What is the most likely cause?

medium

A. Microservices do not support deployment automation

B. The app was too large for microservices

C. They used too many developers

D. They underestimated the complexity of managing microservices

Solution

1. Step 1: Analyze the problem context

   Small apps converted to microservices often face complexity in communication and deployment.

2. Step 2: Identify the cause

   Deployment failures and communication errors usually come from underestimating microservices management overhead.

3. Final Answer:

   They underestimated the complexity of managing microservices -> Option D

4. Quick Check:

   Underestimating complexity = deployment issues [OK]

Hint: Expect extra management work with microservices [OK]

Common Mistakes:

• Blaming microservices for deployment automation lack
• Assuming more developers cause deployment errors
• Thinking large apps cause these specific errors

5. A startup with a small team plans to build a new app. They want to decide between microservices and a monolithic design. Which approach should they choose and why?

hard

A. Start with a monolith to reduce complexity and switch later if needed

B. Start with microservices to prepare for future scaling immediately

C. Use microservices only if the app is a static website

D. Avoid both and build multiple separate apps

Solution

1. Step 1: Consider team size and app complexity

   A small team benefits from simpler monolithic design to reduce overhead and speed development.

2. Step 2: Plan for future growth

   Starting monolithic allows easier initial development; microservices can be adopted later if scaling is needed.

3. Final Answer:

   Start with a monolith to reduce complexity and switch later if needed -> Option A

4. Quick Check:

   Small team = start monolith [OK]

Hint: Small teams start monolith, scale to microservices later [OK]

Common Mistakes:

• Choosing microservices too early for small teams
• Confusing static websites with microservices use
• Ignoring future scalability planning