The layered architecture, also known as the n-tiered architecture style, is one of the most common architecture styles. This style of architecture is the de facto standard for most applications, primarily because of its simplicity, familiarity, and low cost. This is a good choice for small and simple applications and also a good starting point for a greenfield project. This monolithic architecture does not have the complexity associated with distributed architectures.

Pipeline Architecture is more suited to application tasks that have simple one-way processing. Examples include EDI(Electronic Data Interchange) tools, ETL(Extract, Transform, and Load) tools, and Orchestrators such as

Relatively simple monolithic architecture with two components; core system and plug-in components. Application logic is distributed between plug-ins and core system. This architecture often implements a plug-in registry also.

Service-based architecture is considered one of the most pragmatic architecture styles, mostly due to its architectural flexibility. It is a distributed architecture, yet it does not have the complexity and cost of microservices architecture. This is a natural fit with Domain Driven design. Unlike the other distributed architectures, service-based architecture is capable of preserving ACID (Atomicity, Consistency, Isolation, and Durability) transaction.

Event-Driven architecture is a popular distributed asynchronous architecture style used to produce highly scalable and high-performance applications. It could be used for small as well as large scale systems. Event-driven architecture is made up of decoupled event processing components that asynchronously receive and process events. It could be used stand alone or embedded in other architecture styles. Most applications follow a request-based model with request orchestrator and request processors to handle the request. Another is the event-based model.

The space-based architecture style is specifically designed to address problems involving high scalability, elasticity, and high concurrency issues. It is also a useful architecture style for applications that have variable and unpredictable concurrent user volumes. It got its name from the concept of tuple space, the technique of using multiple parallel processors communicating through shared memory. Space-based architecture relies on caching for the transactional processing of an application. Removing the need for direct reads and writes to a database is how space-based architecture is able to support high scalability, high elasticity, and high performance. Space-based architecture mostly relies on replicated caching, although distributed caching can be used as well.

The orchestration engine forms the heart of this distributed architecture, stitching together the business service implementations using orchestration, including features like transactional coordination and message transformation. This architecture is typically tied to a single relational database, or a few, rather than a database per service as in microservices architectures. Thus, transactional behavior is handled declaratively in the orchestration engine rather than in the database. While this approach might sound appealing, in practice it was mostly a disaster. Offloading transaction behavior to an orchestration tool sounded good, but finding the correct level of granularity of transactions became more and more difficult.

Microservices is heavily inspired by the ideas in domain-driven design (DDD), a logical design process for software projects. One concept in particular from DDD, bounded context, decidedly inspired microservices. Microservices form a distributed architecture: each service runs in its own process, which originally implied a physical computer but quickly evolved to virtual machines and containers.