A layered application separates responsibilities—for example, transport/controller, application service, domain logic, and persistence. The separation is valuable only when dependencies remain intentional; a pile of folders does not automatically create good architecture.

A modular monolith deploys as one application while enforcing boundaries between domains. It can provide strong transaction support, simple local calls, and straightforward debugging. Modules should expose narrow interfaces and own their data access rather than reaching into one another's internal tables.

For an early product, this is often a practical baseline. You can scale stateless instances horizontally and move a module to a separate service later if there is a clear reason such as independent scaling, ownership, deployment, or fault isolation.

Microservices are independently deployable services aligned to business capabilities. A service should own a cohesive responsibility and the data needed to fulfill it. Splitting by technical layer—for example, a service for every database table—often creates chatty dependencies and coordinated deployments.

Domain-driven design uses concepts such as bounded contexts, ubiquitous language, aggregates, and domain events to discover boundaries. Two teams may use the same word differently; a “customer” in billing may have different rules from a “customer” in support. Explicit contexts reduce accidental coupling.

Microservices introduce network latency, partial failure, distributed tracing, service discovery, deployment coordination, and data consistency challenges. Independent deployment is useful only if teams can operate services safely and contracts are managed carefully.

Synchronous calls are easy to reason about: the caller waits for a response. They are appropriate when the user needs an immediate result, but latency and availability depend on the downstream path. If A calls B, which calls C, a slow C can consume resources in A and B.

Asynchronous communication lets a producer hand work to a broker or durable queue and continue. It improves burst absorption and decoupling, but requires retries, deduplication, dead-letter handling, event schemas, and a way to observe work that has not completed.

Set deadlines across a request chain. A downstream call should not be allowed to outlive the caller's remaining budget. Use asynchronous processing for tasks such as emails, analytics, and media transcoding when immediate completion is unnecessary.