backend-service-patterns

Implement ports-and-adapters architecture for backend services in Go, Node/TypeScript, or Rust.

2|Updated Jun 26, 2026

Search Tags:#backend #ddd #hexagonal architecture #ports-and-adapters #service architecture

Ready to run

npx skills add https://github.com/bRRRITSCOLD/compainy --skill backend-service-patterns-brrritscold

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: backend-service-patterns
Source: https://github.com/bRRRITSCOLD/compainy/tree/main/skills/backend-service-patterns
Command: npx skills add https://github.com/bRRRITSCOLD/compainy --skill backend-service-patterns-brrritscold

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires gin, fastify, axum, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides a framework for building robust and scalable backend services using the ports-and-adapters architecture. It addresses the challenge of maintaining clean and modular service designs while accommodating diverse external systems and interfaces.

Core Features & Use Cases

Ports-and-Adapters Architecture: Implements the ports-and-adapters architecture pattern, which isolates the domain core logic from external dependencies.
Domain Core: Encapsulates pure business logic with interfaces for external dependencies, ensuring it remains testable and independent.
Adapters: Translates between domain types and external systems, facilitating easy swaps and testing of components.
Use Case: Designing a high-performance backend service with Go, Node/TypeScript, or Rust, using Fastify, Gin, or Axum for HTTP transport.

Quick Start

To apply this Skill to your project, define your domain core, create the necessary adapter implementations, and wire up dependencies following the ports-and-adapters pattern.

Frequently Asked Questions about backend-service-patterns

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

FAQPage Schema

What is ports-and-adapters architecture in backend service design?▼

Ports-and-adapters architecture isolates domain core business logic from external dependencies by defining interfaces for databases, HTTP clients, and message queues, ensuring modular service designs remain testable and easily swappable.

How do I implement hexagonal architecture with Go, Node/TypeScript, or Rust?▼

Implement hexagonal architecture by defining a domain core with business logic interfaces, creating adapter implementations for external systems, and wiring dependencies using supported HTTP frameworks like Gin, Fastify, or Axum.

Can I use Fastify, Gin, and Axum for HTTP transport in a domain-driven design?▼

Yes, Fastify, Gin, and Axum are supported HTTP frameworks for translating between domain types and external systems, facilitating high-performance backend service transport while maintaining a clean domain core.

What's the best way to isolate business logic from database and message queue dependencies?▼

The best way to isolate business logic is using the ports-and-adapters pattern, which encapsulates pure domain core logic with interfaces and translates external interactions through dedicated adapter implementations for easy testing.

When do I need ports-and-adapters for my backend service architecture?▼

You need ports-and-adapters when maintaining clean, modular service designs while accommodating diverse external systems, ensuring your domain core logic remains independent, testable, and scalable across different interfaces.