An architecture style is the overall shape of a system — the vocabulary of proven structures a team can start from instead of inventing shape from scratch. Choosing one is among the highest-leverage, hardest-to-reverse decisions an architect makes.

But no style is 'best'. Each embodies a specific bundle of trade-offs across characteristics. Knowing the catalogue — and what each style buys and costs — is core architectural literacy.

Styles split into monolithic (one deployment unit) and distributed (many).

Layered (n-tier): code organized in horizontal layers (presentation, business, persistence, database). Simple and familiar, low cost — but poor scalability and elasticity, and prone to becoming a big ball of mud.

Modular monolith: a single deployment partitioned into well-bounded modules by domain. Keeps deployment simple while improving modularity.

Microkernel (plug-in): a minimal core plus plug-in components for features. Great for product-style extensibility and customization.

Event-driven: components communicate asynchronously via events (broker or mediator topology). High scalability, performance, and fault tolerance; harder to test and reason about.

Microservices: many small, independently deployable services around bounded contexts. Excellent scalability, deployability, and fault isolation — at high cost in complexity, performance overhead, and operational burden.

Space-based: replicated in-memory processing units with no central database in the request path, scaled via a virtualized 'tuple space'. Built for extreme, unpredictable elasticity and concurrency.

A startup building an internal reporting tool for 50 users picks layered: cheap, simple, no distributed complexity — the driving characteristics are simplicity and cost, and layered wins.

Years later, one feature — real-time bidding — must absorb wild traffic spikes and never lose an event. That subsystem does not fit layered. The team carves it out into an event-driven (and partly space-based) design for elasticity and fault tolerance, while the rest stays a modular monolith.

The lesson: the 'right' style is chosen per set of driving characteristics, and a real system often blends styles. There is no universal winner — only fit.

Choosing a style is FND-02 (trade-off analysis) applied to FND-03 (characteristics): rank the driving characteristics, then pick the style whose trade-off profile matches. Microservices are not 'modern and therefore better' — they are a specific trade of simplicity and performance for scalability and deployability.

Styles also compose: microkernel cores can be event-driven; a modular monolith is often the honest first step toward microservices later, if ever.