home / skills / first-fluke / fullstack-starter / senior-architect

senior-architect skill

safe

This skill provides scalable, maintainable architectural guidance for systems using React, Next.js, Node, and microservices patterns.

npx playbooks add skill first-fluke/fullstack-starter --skill senior-architect

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

Files (1)

SKILL.md

1.8 KB

---
name: senior-architect
description: Comprehensive software architecture skill for designing scalable, maintainable systems using ReactJS, NextJS, NodeJS, FastAPI, Flutter, etc. Includes system design patterns, tech stack decision frameworks, and modularity analysis.
---

# Senior Architect

This skill provides high-level architectural guidance, ensuring the system is scalable, maintainable, and aligned with business goals.

## Core Competencies

### 1. System Design
- **Microservices vs. Monolith**: Evaluate trade-offs based on team size and domain complexity.
- **Event-Driven Architecture**: Use Pub/Sub (Google Cloud Pub/Sub, Redis) for decoupling services.
- **Data Modeling**: Design schemas for relational (Postgres) and NoSQL (Firestore/Redis) databases.

### 2. Code Organization (Monorepo)
- **Shared Packages**: Identify logic suitable for `packages/` (e.g., UI kit, i18n, types).
- **Feature Modules**: encapsulate features rather than technical layers.
- **Dependency Rules**: Enforce strict boundaries (e.g., UI cannot import DB logic directly).

### 3. Cross-Cutting Concerns
- **Observability**: Consistent logging structure and tracing context propagation.
- **Security**: centralized auth verification and secret management.
- **Scalability**: Caching strategies (CDN, Redis, Browser) and database read replicas.

## Decision Framework

When evaluating a new technology or pattern:
1.  **Problem Fit**: Does it solve a real problem we have?
2.  **Cost**: What is the maintenance overhead?
3.  **Team**: Does the team have the skills (or capacity to learn)?
4.  **Lock-in**: How hard is it to replace later?

## When to Use

- "How should we structure the notification system?"
- "Review this DB schema for performance."
- "Should we put this logic in the frontend or backend?"
- "Design a scalable folder structure for the new module."

Overview

This skill delivers pragmatic software architecture guidance for building scalable, maintainable systems using ReactJS, NextJS, NodeJS, FastAPI, Flutter and related technologies. It synthesizes system design patterns, monorepo organization, and decision frameworks to align technical choices with business goals. The focus is on practical, production-ready setups and trade-offs that teams can act on immediately.

How this skill works

I inspect your proposed architecture, repository layout, and technology choices to identify bottlenecks and anti-patterns. The skill evaluates trade-offs—monolith vs microservices, event-driven approaches, data modeling for relational and NoSQL stores—and recommends concrete changes. It also provides modularity checks for monorepos, cross-cutting concern strategies (observability, security, caching), and a repeatable decision framework for future tech choices.

When to use it

Design or review a notification, event or integration system for scale and decoupling.
Decide whether functionality belongs in frontend, backend, or shared packages.
Structure a monorepo with clear feature modules and dependency boundaries.
Validate data models for Postgres, Firestore or Redis for performance and consistency.
Choose between microservices and a monolith based on team size and complexity.

Best practices

Encapsulate features, not layers; expose minimal interfaces between modules.
Enforce dependency rules so UI code cannot import database logic directly.
Adopt event-driven Pub/Sub patterns for loose coupling and horizontal scale.
Standardize logging and trace context propagation for end-to-end observability.
Use a four-point decision checklist: problem fit, cost, team capability, and lock-in.

Example use cases

Architect a notification system using Pub/Sub with retry and deduplication strategies.
Refactor a Next.js + FastAPI monorepo into feature modules and shared packages.
Evaluate moving a service from NodeJS to FastAPI for performance or team readiness.
Design caching layers combining CDN, Redis and client-side strategies for high read throughput.

FAQ

How do I choose between microservices and a monolith?

Base the decision on domain complexity, team size, and operational maturity. Prefer a modular monolith early, split to microservices when ownership, independent scaling, or release velocity justify the added operational cost.

What are quick wins for observability in a new project?

Standardize structured logs, add request tracing across services, and centralize metrics dashboards. Start with high-cardinality error logging and basic distributed tracing to find hotspots.