architecture-patterns

Design backend architectures with Clean Architecture, Hexagonal Architecture, and DDD.

Updated Mar 25, 2026
One-click install
npx skills add https://github.com/MileniumTick/skills --skill architecture-patterns-mileniumtick
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/MileniumTick/skills/tree/main/skills/architecture-patterns
Command: npx skills add https://github.com/MileniumTick/skills --skill architecture-patterns-mileniumtick

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Design and guidance for applying proven backend architecture patterns to improve maintainability, testability, and scalability across projects.

Core Features & Use Cases

  • Provides a structured approach combining Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for backend systems.
  • Guides decomposition into boundaries, ports/adapters, and domain models to enable testability and maintainability.
  • Use cases include designing new services, refactoring monoliths, and establishing architecture standards across teams.

Quick Start

Outline a backend system using clean architecture with domain-driven design principles and hexagonal ports and adapters.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I design backend architecture for scalable and maintainable systems?

Design scalable backend architecture by applying Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. This structured approach defines clear dependency rules, domain boundaries, and ports/adapters to ensure testability and technology-agnostic core logic for new projects or refactors.

What is the difference between Clean Architecture and Hexagonal Architecture for backend services?

Clean Architecture focuses on dependency rules to separate core logic from external layers, while Hexagonal Architecture uses ports and adapters to isolate the domain. Both patterns are combined here with Domain-Driven Design to maximize maintainability and testability across backend systems.

How do I refactor a monolith using Domain-Driven Design and ports and adapters?

Refactor monoliths using Domain-Driven Design to establish bounded contexts and domain models. Hexagonal Architecture ports and adapters are then applied to isolate external dependencies, ensuring the refactored backend achieves a testable, technology-agnostic core.

When should I use DDD patterns in my backend architecture?

Use Domain-Driven Design patterns when establishing architecture standards across teams or designing new services that require clear boundaries and domain models. DDD provides a technology-agnostic core that satisfies requirements for testability and long-term maintainability in complex backend systems.

Can I establish architecture standards across teams using Hexagonal Architecture?

Yes, Hexagonal Architecture standardizes backend systems across teams by enforcing ports and adapters for external integrations. Combined with Clean Architecture and DDD, it establishes clear dependency rules and domain boundaries, ensuring consistent testability and maintainability across multiple projects.

Do I need a technology-agnostic core to implement Clean Architecture?

Yes, a technology-agnostic core is a fundamental requirement of Clean Architecture. By isolating domain models and business logic from external frameworks through defined boundaries and ports/adapters, the architecture ensures high testability and maintainability for your backend systems.