Design Patterns vs. Architectural Patterns

This post clarifies the distinction between design patterns and architectural patterns, including exam questions and key takeaways.

In a Nutshell

Design patterns solve recurring problems at the class and object level. Architectural patterns structure the entire application at a higher level.

Quick Technical Definition

• Design Patterns: tactical solutions at the code level (e.g., Singleton, Factory, Observer).
• Architectural Patterns: strategic macrostructure (e.g., MVC, Layered/n-Tier, Microservices).

Both improve maintainability and reusability, but they operate on different scales.

Exam-Relevant Points

• Design patterns = class level
• Architectural patterns = system level
• Design patterns often exist within architectural patterns
• Architecture decisions impact scalability and cost (relevant for professional certifications)
• Both require justification and documentation

Core Components

1. GoF patterns
2. Creational/Structural/Behavioral patterns
3. MVC
4. Layered Architecture
5. Microservices
6. EDA
7. DDD
8. UML documentation

Practical Example

// Design Pattern: Factory
class UserFactory {
  public static User create(String name) {
    return new User(name);
  }
}

// Architectural Pattern: MVC
// Model = User.java, View = Frontend, Controller = Routing

Strengths and Weaknesses

Strengths

• Better readability and reusability (design patterns)
• Improved teamwork and maintainability (architectural patterns)

Weaknesses

• Misapplication leads to overengineering
• Architectural patterns increase upfront effort

Common Exam Questions (with Brief Answers)

1. What is a design pattern? A reusable solution at the class level.
2. What is an architectural pattern? A structural approach for the entire software system.
3. How are they related? Design patterns are applied within an architecture.

Free Response

In exams, the key is recognizing whether the question asks for a code-level solution or overall system structure. Good architecture applies appropriate design patterns while avoiding unnecessary complexity.

Learning Strategy

1. Read patterns on refactoring.guru.
2. Draw UML diagrams for one design pattern and one architectural pattern.
3. Practice classifying examples as either design or architecture.
4. Avoid over-patternization.

Topic Analysis

• Core: Structuring
• Challenges: Complexity
• Security: Layer separation
• Documentation: Diagrams and rationale
• Economics: Long-term maintenance

Further Reading

1. https://refactoring.guru/design-patterns
2. https://martinfowler.com/architecture/