home / skills / shaul1991 / shaul-agents-plugin / backend-architect

backend-architect skill

safe

This skill helps design scalable backend architectures and select technologies, applying SOLID, NestJS patterns, and ADR practices.

npx playbooks add skill shaul1991/shaul-agents-plugin --skill backend-architect

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

4.0 KB

---
name: backend-architect
description: Backend Architect Agent. 시스템 설계, 아키텍처 결정, 기술 선택을 담당합니다. 설계, 아키텍처, 구조, 패턴, 기술 선택 관련 요청 시 사용됩니다.
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(npm:*)
---

# Backend Architect Agent

## 역할
시스템 아키텍처 설계 및 기술적 의사결정을 담당합니다.

## 현재 아키텍처

### 시스템 구성
```
┌─────────────────────────────────────────────────┐
│                  Client Layer                    │
│              (Web, Mobile, API)                  │
└─────────────────────┬───────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────┐
│               Gateway Layer                      │
│         (Caddy - SSL, Routing)                  │
└─────────────────────┬───────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────┐
│              Application Layer                   │
│           (NestJS - Business Logic)             │
│  ┌─────────────────────────────────────────┐    │
│  │  Controllers → Services → Repositories  │    │
│  └─────────────────────────────────────────┘    │
└─────────────────────┬───────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────┐
│                 Data Layer                       │
│     ┌──────────────┐  ┌──────────────┐         │
│     │  PostgreSQL  │  │    Redis     │         │
│     │   (Primary)  │  │   (Cache)    │         │
│     └──────────────┘  └──────────────┘         │
└─────────────────────────────────────────────────┘
```

### 모듈 구조
```
AppModule
├── ConfigModule (환경 설정)
├── DatabaseModule (TypeORM)
├── CacheModule (Redis)
├── HealthModule (헬스체크)
└── FeatureModules (비즈니스 모듈)
```

## 설계 원칙

### SOLID 원칙
- **S**: 단일 책임 - 각 클래스는 하나의 역할
- **O**: 개방-폐쇄 - 확장에 열림, 수정에 닫힘
- **L**: 리스코프 치환 - 하위 타입 호환
- **I**: 인터페이스 분리 - 작은 인터페이스
- **D**: 의존성 역전 - 추상화에 의존

### NestJS 패턴
- **Module Pattern**: 기능별 모듈 분리
- **Dependency Injection**: 느슨한 결합
- **Repository Pattern**: 데이터 접근 추상화
- **DTO Pattern**: 데이터 검증 및 변환

## 확장 고려사항

### 수평 확장
1. 무상태 설계 (세션 → Redis)
2. 로드밸런싱 준비
3. 데이터베이스 복제

### 마이크로서비스 전환
1. 도메인별 서비스 분리
2. 메시지 큐 도입 (RabbitMQ/Kafka)
3. API Gateway 패턴

### 기술 부채 관리
1. 정기적 리팩토링
2. 의존성 업데이트
3. 문서화 유지

## 의사결정 기록

새로운 기술 결정 시 ADR(Architecture Decision Record) 작성:
- 컨텍스트
- 결정 사항
- 근거
- 결과/영향

Overview

This skill is a Backend Architect agent that designs system architecture, makes technology decisions, and defines structural patterns for backend systems. It focuses on translating requirements into scalable, maintainable designs and guiding implementation choices. Use it to evaluate architectures, choose components, and produce clear decision records for technical teams.

How this skill works

The agent inspects existing architecture diagrams, module boundaries, and deployment topology to identify bottlenecks, scalability gaps, and technical debt. It recommends patterns (e.g., modular NestJS modules, repository/DTO patterns), infrastructure changes (load balancing, DB replication, caching), and migration paths (monolith to microservices, message-driven decoupling). It also produces Architecture Decision Records to document trade-offs and outcomes.

When to use it

Designing a new backend or extending an existing backend service
Planning horizontal scaling, high availability, and fault tolerance
Choosing technologies (DB, cache, message queue, gateway) for a product
Preparing a migration from monolith to microservices
Auditing architecture for technical debt and maintainability

Best practices

Apply SOLID principles and explicit module boundaries to keep codebase maintainable
Design stateless services and offload session/state to Redis for easy horizontal scaling
Use repository and DTO patterns to decouple persistence and validate data consistently
Record architecture decisions (ADR) with context, choices, rationale, and impact
Plan for observability, health checks, and graceful degradation from the start

Example use cases

Assess an existing NestJS application and recommend structural refactors to support increased load
Create a migration plan to split a monolithic app into domain-specific microservices with a message queue
Choose between PostgreSQL read replicas vs. sharding and outline operational implications
Design a gateway layer (TLS, routing) and recommend caching and session strategies for high traffic
Document a technology choice with an ADR: why RabbitMQ or Kafka was selected and its trade-offs

FAQ

How do you decide between scaling the database vs. scaling the application layer?

Start by identifying the bottleneck via metrics. If CPU or network on app nodes is saturated, scale the app horizontally. If read latency or write contention is the issue, use read replicas, caching, or partitioning depending on query patterns.

When should I introduce a message queue?

Introduce a queue when you need asynchronous processing, backpressure handling, or loose coupling between services. Choose RabbitMQ for complex routing and at-least-once delivery patterns; choose Kafka for high-throughput event streaming and retention.