skills.rest
MrPointer
MrPointerCOMMUNITY
Explore all skills by this author →
GitHub

applying-architecture-patterns

Implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for backend systems.

2|Updated Aug 6, 2021
Search Tags:#architecture#design patterns#ddd#hexagonal architecture#clean architecture#backend development
One-click install
npx skills add https://github.com/MrPointer/dotfiles --skill applying-architecture-patterns
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: applying-architecture-patterns
Source: https://github.com/MrPointer/dotfiles/tree/main/dot_claude/skills/applying-architecture-patterns
Command: npx skills add https://github.com/MrPointer/dotfiles --skill applying-architecture-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the challenge of designing and implementing backend systems that are maintainable, testable, and scalable by applying established architectural patterns.

Core Features & Use Cases

  • Clean Architecture: Implement layered architecture for separation of concerns and testability.
  • Hexagonal Architecture: Utilize ports and adapters for technology-agnostic domain logic.
  • Domain-Driven Design (DDD): Apply strategic and tactical patterns for complex business domains.
  • Use Case: When designing a new e-commerce platform, use this Skill to structure the backend using Clean Architecture principles, ensuring business logic remains independent of the chosen database or web framework.

Quick Start

Apply Clean Architecture principles to a new backend system design.

Frequently Asked Questions about applying-architecture-patterns

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

FAQPage Schema
How do I implement Domain-Driven Design patterns like aggregates and bounded contexts in a backend system?▼

Applying Clean Architecture involves structuring your backend into distinct layers to enforce separation of concerns. This isolates business logic from external frameworks and databases, resulting in a robust, testable, and maintainable system design.

What is the best way to refactor a monolithic backend into loosely coupled microservices?▼

Refactoring a monolith into microservices requires decomposing the system by establishing bounded contexts and applying Hexagonal Architecture. Utilizing ports and adapters isolates domain logic, enabling smooth migration to loosely coupled, testable architectures.

How does Hexagonal Architecture use ports and adapters to create technology-agnostic domain logic?▼

You can establish team standards for backend architecture by adopting structured patterns like Clean Architecture and DDD. Defining consistent approaches for entities, use cases, and adapters ensures all team members build testable code with shared architectural boundaries.

When should I use Clean Architecture versus Hexagonal Architecture for a new backend system?▼

Use Clean Architecture for strict layered separation of concerns, or Hexagonal Architecture when emphasizing technology-agnostic domain logic through ports and adapters. Both patterns produce robust, maintainable backend systems by isolating business rules from external dependencies.

Related Skills

Explore More Software Engineering Skills→
iceflowericeflower

ddd

Apply Domain-Driven Design patterns to model aggregates and bounded contexts.

Community
Advanced
truongnattruongnat

clean-architecture

Structure NestJS/TypeScript backends with Clean Architecture, DDD, and Hexagonal layers.

Community
Advanced
DVNghiemDVNghiem
20

clean-architecture

Apply Clean Architecture boundaries to isolate domain logic from infrastructure.

Community
Advanced
doanchienthangdevdoanchienthangdev
4

event-driven-architecture

Implement event sourcing, CQRS, and message queues with RabbitMQ and Kafka.

Community
Advanced