senior-architect

kriscard's avatarfrom kriscard

Comprehensive software architecture for designing scalable, maintainable systems. Use when designing system architecture, making technical decisions, creating architecture diagrams, or evaluating trade-offs.

⭐0stars🔀0forks📁View on GitHub🕐Updated Jan 6, 2026
[Architecture Design]

When & Why to Use This Skill

This Claude skill serves as a comprehensive toolkit for software architects and lead developers to design scalable, maintainable, and high-performance systems. It facilitates critical technical decision-making by evaluating trade-offs between monolithic and microservices architectures, selecting optimal database patterns, and defining robust API contracts. By leveraging industry-standard frameworks like the C4 model and Architecture Decision Records (ADRs), it ensures that system designs are well-documented, technically sound, and aligned with long-term scalability requirements.

Use Cases

  • Case 1: Designing a new system architecture from scratch, including functional requirements gathering and high-level component mapping.
  • Case 2: Evaluating and planning a migration strategy from a monolithic architecture to microservices as team size and system complexity grow.
  • Case 3: Creating professional architectural documentation using the C4 model and Mermaid diagrams to communicate system structure to stakeholders.
  • Case 4: Making and documenting critical technical decisions (e.g., SQL vs. NoSQL, REST vs. GraphQL) using formal Architecture Decision Records (ADRs).
  • Case 5: Optimizing system performance and reliability through the implementation of advanced database patterns like sharding, read replicas, or CQRS.
namesenior-architect
descriptionComprehensive software architecture for designing scalable, maintainable systems. Use when designing system architecture, making technical decisions, creating architecture diagrams, or evaluating trade-offs.

Senior Architect

Complete toolkit for system design and architecture decisions.

Tech Stack

Languages: TypeScript, JavaScript, Python, Go, Swift, Kotlin Frontend: React, Next.js, React Native, Flutter Backend: Node.js, Express, GraphQL, REST APIs Database: PostgreSQL, Prisma, Supabase DevOps: Docker, Kubernetes, Terraform, GitHub Actions Cloud: AWS, GCP, Azure

Architecture Patterns

Monolith vs Microservices

Aspect Monolith Microservices
Complexity Lower initially Higher, but scales better
Deployment Single unit Independent services
Team scaling Harder beyond 10 devs Enables team autonomy
Debugging Easier Requires distributed tracing

Decision: Start monolith, extract when team/scale demands.

API Design

REST:

  • Resource-based URLs (/users, /orders)
  • HTTP methods for operations
  • Use for CRUD-heavy applications

GraphQL:

  • Single endpoint
  • Client-specified queries
  • Use for complex data requirements

Database Patterns

  • Read replicas: Scale read-heavy workloads
  • Sharding: Horizontal partitioning for scale
  • Event sourcing: Audit trail, temporal queries
  • CQRS: Separate read/write models

System Design Process

1. Requirements

  • Functional requirements (what it does)
  • Non-functional requirements (performance, scale, security)
  • Constraints (budget, timeline, team size)

2. High-Level Design

  • Component identification
  • Data flow mapping
  • Integration points

3. Detailed Design

  • API contracts
  • Database schema
  • Error handling
  • Caching strategy

4. Trade-offs

  • Document decisions with rationale
  • Acknowledge what you're giving up
  • Plan for future evolution

Diagram Types

C4 Model

  1. Context: System and external actors
  2. Container: Applications and data stores
  3. Component: Internal modules
  4. Code: Class-level (rarely needed)

Other Diagrams

  • Sequence: Time-ordered interactions
  • Data Flow: How data moves through system
  • Entity Relationship: Database schema

Best Practices

Code Quality

  • Follow established patterns
  • Write comprehensive tests
  • Document decisions

Performance

  • Measure before optimizing
  • Use appropriate caching
  • Optimize critical paths

Security

  • Validate all inputs
  • Use parameterized queries
  • Implement proper authentication

Maintainability

  • Write clear code
  • Use consistent naming
  • Keep it simple

Output Standards

  • Architecture Decision Records (ADRs)
  • C4 diagrams in Mermaid format
  • System design documents
  • API specifications
  • Database schema documentation