backend-architect

Design microservices, service boundaries, and APIs across REST, GraphQL, and gRPC stacks.

Updated Feb 26, 2026
One-click install
npx skills add https://github.com/AndyAnh174/wellness --skill backend-architect-andyanh174
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-architect
Source: https://github.com/AndyAnh174/wellness/tree/main/.agent/skills/backend-architect
Command: npx skills add https://github.com/AndyAnh174/wellness --skill backend-architect-andyanh174

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designing robust backend systems and APIs to meet performance, scale, and reliability requirements across evolving business needs.

Core Features & Use Cases

  • Service boundary definition based on domain-driven design to enable maintainable, scalable architectures.
  • Resilience patterns such as circuit breakers, retries, timeouts, and graceful degradation implemented from day one.
  • Observability and security through structured logging, metrics, tracing, and secure inter-service communication.
  • Real-world use cases include migrating from monoliths to microservices, defining API contracts across REST/GraphQL/gRPC, and implementing service meshes.

Quick Start

Design an initial backend blueprint outlining service boundaries, required APIs, and resilience patterns for a new microservices-based application.

Frequently Asked Questions about backend-architect

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

FAQPage Schema
How do I design microservices with proper service boundaries?

Designing microservices with proper service boundaries involves applying domain-driven design to establish maintainable, scalable architectures. This approach enables clear separation of concerns and supports distributed systems across REST, GraphQL, and gRPC stacks in cloud-native environments.

What resilience patterns should I implement for distributed backend systems?

Resilience patterns for distributed backend systems include circuit breakers, retries, timeouts, and graceful degradation. Implementing these patterns from day one ensures robust API design and maintains service availability during partial failures across microservices architectures.

How do I add observability and security to a microservices architecture?

Observability and security in a microservices architecture are achieved through structured logging, metrics, tracing, and secure inter-service communication. These practices provide deep visibility into distributed systems and protect API endpoints across cloud-native environments.

What is the best way to migrate from a monolith to microservices?

The best way to migrate from a monolith to microservices is by defining initial backend blueprints that outline service boundaries, required APIs, and resilience patterns. This structured approach ensures scalable backend architecture and reliable distributed systems migration.

Can I use this approach to define API contracts across REST, GraphQL, and gRPC?

Yes, this approach explicitly defines API contracts across REST, GraphQL, and gRPC stacks. It supports modern cloud-native backend architecture by standardizing inter-service communication and implementing secure boundaries for distributed systems.

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

You should avoid microservices architecture when your backend systems do not require independent scaling or complex distributed resilience patterns. If your application lacks evolving business needs and domain-driven boundaries, a simpler monolithic API design is more appropriate.