Small, independently deployable services; each owns a bounded capability.
Microservices are an architectural style that structures an application as a set of loosely coupled, independently deployable services. Each service typically owns a slice of business capability and its own data store, communicates over networks via APIs or events, and can be developed, deployed, and scaled by a team with clear ownership. The aim is to improve scalability, resilience, and delivery speed compared to a single large monolith.
Adopting microservices involves trade-offs. You gain flexibility in technology choices per service, the ability to scale components independently, and clearer boundaries that can align with team structure. You also take on distributed-system complexity: network failures, eventual consistency, cross-service tracing, and operational overhead. Service boundaries should align with business capabilities and bounded contexts from domain-driven design, rather than being cut by technical layers. Communication can be synchronous (e.g. REST or gRPC) or asynchronous (messaging, events); both have a place, and many systems use a mix.
Running microservices in production requires robust practices: health checks, circuit breakers and retries, distributed tracing, and clear deployment and rollback procedures. Cloud platforms like Azure provide services for hosting (e.g. App Service, AKS), messaging (Service Bus, Event Grid), and observability (Application Insights). Success with microservices depends as much on organization and ownership as on technology: Conway’s law suggests that system design and team structure tend to align, so boundaries should be chosen with that in mind.