architecture-patterns

Design backend architectures using Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.

1|Updated Nov 9, 2025
One-click install
npx skills add https://github.com/drgaciw/academic-athletics-saas --skill architecture-patterns-drgaciw
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/drgaciw/academic-athletics-saas/tree/main/.claude/skills/backend-development/architecture-patterns
Command: npx skills add https://github.com/drgaciw/academic-athletics-saas --skill architecture-patterns-drgaciw

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Architecture decisions often become a tangle as backend systems grow. This Skill teaches how to apply proven patterns—Clean Architecture, Hexagonal Architecture, and Domain-Driven Design—to build maintainable, testable, and scalable backends.

Core Features & Use Cases

  • Clear separation of concerns: Learn the layering, ports/adapters, and bounded contexts that keep business rules independent from frameworks.
  • Pattern-driven design: Apply Clean Architecture, Hexagonal Architecture, and DDD to new projects, refactor monoliths, and set team-wide standards.
  • Practical guidance: Understand entities, value objects, aggregates, repositories, and domain events with concrete examples and diagrams.

Quick Start

Set up a new backend module using the described patterns to organize domain logic, interfaces, and implementations.

Frequently Asked Questions about architecture-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure a backend service using clean architecture and domain-driven design?

Structure your backend by applying clean architecture and domain-driven design to separate business logic from frameworks. This approach enforces separation of concerns, testability, and portability, ensuring maintainable services as systems grow.

What is the best way to refactor a monolith using hexagonal architecture?

Refactoring a monolith with hexagonal architecture involves implementing ports and adapters to isolate domain logic. This pattern keeps business rules independent from external frameworks, improving testability and allowing incremental migration.

When do I need bounded contexts and aggregates in backend software design?

You need bounded contexts and aggregates in backend software design when managing complex business domains. Domain-driven design uses these patterns to establish clear boundaries, keeping entities and value objects consistent across large teams.

Does clean architecture work for establishing standards across multiple backend teams?

Yes, clean architecture works for establishing team-wide backend standards. It provides a strict layering approach that separates domain rules from infrastructure, ensuring multiple teams can collaborate on maintainable and testable services.

How do I implement repositories and domain events in a maintainable backend?

Implement repositories and domain events by following domain-driven design principles to manage data access and state changes. This keeps business logic decoupled from infrastructure frameworks, resulting in a highly maintainable and testable backend.