Course contentsShow
← Software Engineering
Lesson 1333 of 1,93339. Microservices ArchitectureFree lesson

Team Size and Conway's Law

Learn how team structure drives architecture: microservices align well with multiple autonomous teams owning distinct services.

Team Size and Conway's Law

What You'll Learn

You'll learn how your organization's communication structure directly shapes your software architecture—and why microservices naturally align with autonomous, domain-focused teams.

Conway's Law Explained

In 1967, Melvin Conway observed: "Organizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations."

In plain English: Your software architecture will mirror how your teams talk to each other.

If you have three teams building an API, you'll likely end up with three distinct API layers. If teams are siloed by frontend/backend/database, your system will have rigid boundaries between those layers.

Team Size and Microservices

Microservices align naturally with multiple small, autonomous teams (often following Amazon's "two-pizza team" rule—roughly 5-9 people). Here's why:

  • One team, one service (or small cluster): Each team owns its bounded context end-to-end
  • Minimal cross-team coordination: Teams communicate through well-defined service contracts, not constant meetings
  • Independent deployment: Small teams can ship without waiting for a massive synchronized release
  • Clear ownership: When a service fails, everyone knows which team owns it

Conversely, if you have a single team of 6 developers, forcing a microservices architecture creates artificial complexity—they'll spend more time managing distributed system problems than delivering features.

The Organizational Prerequisite

Conway's Law teaches us that architecture changes require organizational changes. You can't successfully adopt microservices while keeping a single, monolithic team structure. The communication overhead and deployment dependencies will fight your architectural goals.

Key Takeaway: Microservices succeed when team structure and service boundaries align—multiple autonomous teams naturally benefit from independently deployable services, while small teams are better served by modular monoliths.