architecture-patterns

Architect backend systems with Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.

Updated Apr 9, 2026
One-click install
npx skills add https://github.com/raksok/netherica --skill architecture-patterns-raksok
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/raksok/netherica/tree/main/.agents/skills/architecture-patterns
Command: npx skills add https://github.com/raksok/netherica --skill architecture-patterns-raksok

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps software teams design and implement robust backend systems by applying established patterns such as Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to improve maintainability, testability, and scalability.

Core Features & Use Cases

  • Provides a structured approach to defining boundaries, modules, and dependencies.
  • Offers guidance on applying multiple architecture patterns to different domains.
  • Includes practical playbooks and templates to accelerate architectural decisions.

Quick Start

Outline your domain, choose a pattern, and map interfaces and boundaries to begin applying architecture best practices.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I apply domain-driven design to structure a new backend service?

Apply domain-driven design by outlining your domain, choosing an architecture pattern, and mapping interfaces and boundaries. This approach defines clear layers and domain modeling guidelines to improve maintainability and testability for new backend services.

What is the difference between clean architecture and hexagonal architecture for backend design?

Clean architecture and hexagonal architecture both separate domain logic from infrastructure using defined layers and ports and adapters. This Skill provides practical playbooks to help teams choose and apply the appropriate pattern based on their specific domain boundaries.

How do I refactor a monolith using ports and adapters?

Refactor a monolith using ports and adapters by defining clear module boundaries and dependencies to separate domain logic from external interfaces. This Skill provides structured approaches and templates to accelerate aligning teams around these domain boundaries.

Can I use these architecture patterns for scaling existing backend systems?

These architecture patterns apply to scaling existing backend systems by standardizing practices for maintainability and testability. You can use the provided templates to map interfaces and align domain boundaries during system refactoring.

When should I not use domain-driven design for backend architecture?

Domain-driven design may be unnecessary for simple backend systems without complex domain logic. If your service requires minimal domain modeling or has limited scalability requirements, the overhead of defining bounded contexts and ports and adapters might not be justified.