Software Architecture & Design Patterns Interview Prep

Design patterns interview questions test whether you can apply the Gang-of-Four classics to real Java code — Singleton (and why it is a smell), Factory and Abstract Factory, Builder (with the Java records angle), Strategy, Observer, Decorator, Adapter, Proxy, and the patterns Spring itself uses (Template Method, IoC, AOP). Each answer leads with the problem the pattern solves, the Java implementation, and the trade-offs (when not to use it).

Three families — name the family before the pattern.

• Creational — Factory, Abstract Factory, Builder, Singleton, Prototype.
• Structural — Adapter, Decorator, Facade, Proxy, Composite, Bridge, Flyweight.
• Behavioural — Strategy, Observer, Template Method, Command, State, Iterator, Chain of Responsibility.

Spring uses many by default — DI ≈ inversion-of-control, AOP ≈ proxy, JdbcTemplate ≈ template method.

The interview surface for this module breaks into these focus areas:

• Behavioral patterns — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Comparisons — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Creational patterns — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Design patterns legacy — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Refactoring — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Solid principles — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Structural patterns — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Technical debt — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Scenario-based — applied questions tying multiple topics together. Drill these last, after the fundamentals are sharp.

• Singleton is a smell when global state lurks — prefer DI scope.
• Strategy vs State — same shape, different intent: strategy is interchangeable, state is contextual.
• Builder for records — modern Java needs less of it.
• Composition is the meta-pattern — most patterns are composition in disguise.
• Anti-patterns count too — God object, anaemic domain, magic numbers.

"This problem is a classic from the family — it gives me . The trade-off is , and I'd skip the pattern when ."

Software architecture interview questions cover the higher-level patterns senior interviews probe — layered vs hexagonal vs clean architecture, DDD (entities, aggregates, bounded contexts, ubiquitous language), CQRS and event sourcing, the SOLID principles applied at the system level, modular monolith vs microservices, and the architectural trade-offs interviewers love to discuss (consistency vs availability, cohesion vs coupling). Use this page for staff/principal-level interviews where the question is rarely "how would you implement X" and more often "how would you decompose Y".

Four lenses for any architecture question:

• Layered — easy, but couples to data model.
• Hexagonal / Ports & Adapters — domain in the middle, infra on the edges.
• Clean — concentric layers, dependency rule points inward.
• DDD — bounded contexts, aggregates, ubiquitous language.

Pick the lightest that solves the problem. Senior signal = articulate trade-offs.

The interview surface for this module breaks into these focus areas:

• Architectural styles — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Clean architecture — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Comparisons — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Cqrs and event sourcing — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Domain driven design — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Hexagonal architecture — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Microservices patterns — drill the named patterns, the failure modes, and the recommended Java / framework idiom.
• Scenario-based — applied questions tying multiple topics together. Drill these last, after the fundamentals are sharp.

• DDD aggregates — one transactional boundary, identity by ID, rules inside.
• CQRS — different models for read and write; events keep them in sync.
• Modular monolith — the underrated default; 95% of teams don't need microservices.
• Conway's law — architecture mirrors org structure.
• Reversible vs one-way doors — invest the most thought in one-way doors (data model, public APIs).

"I'd start with a modular monolith using hexagonal boundaries, isolate the domain from infra, draw with explicit integration patterns, and only split into services when demands it."