backend-architect

Creates architectural blueprints with API contracts, resilience patterns, and monitoring strategies for microservices.

54|18|Updated Jan 21, 2026
One-click install
npx skills add https://github.com/hainamchung/agent-assistant --skill backend-architect-hainamchung
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-architect
Source: https://github.com/hainamchung/agent-assistant/tree/main/skills/backend-architect
Command: npx skills add https://github.com/hainamchung/agent-assistant --skill backend-architect-hainamchung

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Backend systems often become bottlenecks due to unclear boundaries, brittle contracts, and insufficient observability. This skill helps craft scalable, resilient architectures that align with business requirements and non-functional goals.

Core Features & Use Cases

  • API design & patterns (REST, GraphQL, gRPC)
  • Service boundaries & API contracts (DDD, bounded contexts)
  • Resilience & fault tolerance (circuit breakers, retries, timeouts)
  • Observability & monitoring (logging, metrics, tracing)
  • Deployment & operations guidance (CI/CD, containerization, scalable infrastructure)
  • Use Case: design a new microservice with clear ownership and an observable deployment plan.

Quick Start

Provide a high-level backend architecture plan including boundaries, API contracts, and resilience guidelines for a new service.

Frequently Asked Questions about backend-architect

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

FAQPage Schema
How do I design scalable microservices with clear service boundaries?

Design scalable microservices by applying Domain-Driven Design to define bounded contexts, mapping business requirements to clear ownership. This approach ensures maintainable service boundaries and robust API contracts that prevent bottlenecks as the system grows.

What is contract-first API design and when should I use it for backend architecture?

Contract-first API design defines API contracts before implementation, ensuring clear inter-service communication across REST, GraphQL, or gRPC. Use it when designing new microservices or refactoring monoliths to prevent brittle dependencies and align non-functional goals.

How do I add resilience and fault tolerance to a microservices backend?

Add resilience to a microservices backend by implementing circuit breakers, retries, and timeouts. These fault tolerance patterns prevent cascading failures and ensure the architecture remains robust during partial outages or high-latency scenarios.

What's the best way to plan observability and monitoring for a new service?

Plan observability by integrating logging, metrics, and distributed tracing into the architecture. This combination provides deep visibility into service behavior, allowing operations teams to monitor deployments and quickly identify bottlenecks.

Does this approach work for refactoring a monolith into microservices?

Yes, the approach supports refactoring monoliths by identifying bounded contexts to establish clear service boundaries. It maps existing business logic to robust API designs and establishes inter-service communication protocols for a smooth migration.

When should I not use a microservices architecture for my backend?

Avoid microservices when business requirements are simple or team scale is small, as the overhead of managing inter-service communication, observability, and deployment complexity outweighs the resilience benefits of distributed service boundaries.