architecture-patterns-guide

Design scalable layered architectures for Rust API backends and React frontends.

1|Updated Mar 19, 2024
One-click install
npx skills add https://github.com/doitsu2014/my-cms --skill architecture-patterns-guide
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns-guide
Source: https://github.com/doitsu2014/my-cms/tree/main/.claude
Command: npx skills add https://github.com/doitsu2014/my-cms --skill architecture-patterns-guide

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a comprehensive blueprint for designing and implementing scalable software architectures, focusing on Rust-based backends (Axum, SeaORM) and React frontends. It helps teams standardize layered architecture, command-handler patterns, GraphQL integration, and deployment practices across projects.

Core Features & Use Cases

  • Layered architecture guidance for backend, frontend, and infrastructure.
  • Command-handler pattern, GraphQL integration, transaction management, testing patterns, and deployment practices.
  • Use cases include building a headless CMS-style system with clear separation of concerns and scalable deployment pipelines.

Quick Start

Inspect the repository's architecture guide, align your project structure to the described layers, implement the command-handler pattern for a new domain entity, wire GraphQL in, and apply the deployment patterns described.

Frequently Asked Questions about architecture-patterns-guide

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

FAQPage Schema
How do I structure a scalable Rust API using Axum and SeaORM?

Structure a scalable Rust API by applying a layered architecture that enforces dependency inversion and modular boundaries. This approach uses command-handler patterns and infrastructure practices to maintain clear separation of concerns for headless CMS-style systems.

What is the command-handler pattern in GraphQL API design?

The command-handler pattern in GraphQL API design separates domain logic execution from query resolution. It enforces modular boundaries and transaction management, enabling reliable deployment pipelines for teams building scalable Rust backends.

How do I apply layered architecture to a React frontend?

Apply layered architecture to a React frontend by aligning project structures with backend boundaries and enforcing modular separation. This standardizes frontend patterns and ensures clear separation of concerns across the full stack.

Can I use this architecture guide for building a headless CMS?

Yes, you can use this architecture guide for building a headless CMS. It specifically targets headless CMS-like systems by providing blueprints for clear layered architecture, robust command-handler patterns, and reliable deployment pipelines.

Does dependency inversion help with Rust and React full stack scalability?

Dependency inversion helps with Rust and React full stack scalability by enforcing modular boundaries between infrastructure and domain layers. This ensures clear separation of concerns and supports reliable deployment pipelines across projects.