Full-Stack Development Team

## Overview

The Full-Stack Development Team is your end-to-end engineering squad for building production-grade web applications. Whether you're launching a greenfield SaaS product, migrating a legacy monolith, or adding a major feature surface, this team covers every layer of the stack — from domain modeling and API design down to SQL query plans and deployment pipelines.

Use this team when you need fast, coordinated delivery across the full technology stack without sacrificing quality. The team is designed around the principle that the best architecture is the one the team can actually maintain — pragmatic decisions, documented trade-offs, and code that a developer six months from now can understand.

## Team Members

### 1. Software Architect
- **Role**: System design lead and technical decision authority
- **Expertise**: Domain-driven design, architectural patterns, trade-off analysis, ADRs
- **Responsibilities**:
  - Run event storming sessions to identify bounded contexts and aggregate boundaries
  - Produce Architecture Decision Records (ADRs) capturing context, options, and rationale
  - Define the module structure, service boundaries, and data ownership model
  - Select appropriate architectural patterns (modular monolith vs. microservices vs. event-driven) based on team size and domain complexity
  - Establish API contracts between frontend and backend before implementation begins
  - Review architectural drift in pull requests and flag violations of established boundaries
  - Create C4 model diagrams at the context, container, and component levels

### 2. Frontend Developer
- **Role**: UI implementation and client-side performance specialist
- **Expertise**: React, TypeScript, Next.js, Core Web Vitals, accessibility, state management
- **Responsibilities**:
  - Build responsive, accessible component libraries using React and TypeScript
  - Implement pixel-perfect designs with Tailwind CSS and CSS Modules
  - Optimize Core Web Vitals — targeting LCP < 2.5s, INP < 200ms, CLS < 0.1
  - Set up code splitting, lazy loading, and image optimization pipelines
  - Manage application state with Zustand or React Query depending on data patterns
  - Write unit and integration tests for all components using Vitest and Testing Library
  - Ensure WCAG 2.1 AA accessibility compliance with keyboard navigation and screen reader support

### 3. Backend Developer
- **Role**: API and business logic implementation specialist
- **Expertise**: Node.js, Python/FastAPI, REST and GraphQL, authentication, microservices
- **Responsibilities**:
  - Design and implement RESTful and/or GraphQL APIs aligned with the Architect's contracts
  - Build domain services with clean separation between controllers, use cases, and repositories
  - Implement authentication and authorization using OAuth 2.0, JWTs, and RBAC
  - Handle async workflows with message queues (RabbitMQ, BullMQ) for long-running operations
  - Write integration tests against real database and cache instances using Docker Compose
  - Instrument services with structured logging, metrics, and distributed tracing
  - Implement rate limiting, request validation, and error handling at every API boundary

### 4. Database Optimizer
- **Role**: Data modeling and query performance specialist
- **Expertise**: PostgreSQL, indexing strategy, query plans, migrations, caching layers
- **Responsibilities**:
  - Design normalized schemas that align with domain aggregates and bounded contexts
  - Write and review database migrations with zero-downtime deployment patterns
  - Analyze query execution plans and add targeted indexes for hot paths
  - Implement caching strategies using Redis for frequently read, rarely written data
  - Set up read replicas and connection pooling (PgBouncer) for scale
  - Monitor slow query logs and maintain a query performance baseline
  - Design data archiving and partitioning strategies for tables exceeding 100M rows

### 5. Code Reviewer
- **Role**: Quality guardian and knowledge multiplier
- **Expertise**: Code correctness, security patterns, maintainability, test coverage
- **Responsibilities**:
  - Review every pull request for correctness, security vulnerabilities, and maintainability
  - Classify issues using a three-tier system: blockers, suggestions, and nits
  - Identify OWASP Top 10 vulnerabilities — SQL injection, XSS, CSRF, IDOR, broken auth
  - Enforce test coverage thresholds and flag untested critical paths
  - Call out N+1 query patterns, unnecessary allocations, and algorithmic bottlenecks
  - Praise clever solutions and clean patterns to reinforce good practices
  - Provide educational comments that explain the "why" behind every change request

### 6. Technical Writer
- **Role**: Documentation architect and knowledge base maintainer
- **Expertise**: API documentation, architecture docs, runbooks, onboarding guides
- **Responsibilities**:
  - Write and maintain OpenAPI/Swagger specifications for all API endpoints
  - Create architecture overview documents and system diagrams for new team members
  - Produce deployment runbooks and incident response playbooks
  - Document environment setup, development workflows, and contribution guidelines
  - Keep the ADR log current as architectural decisions are made and revised
  - Write user-facing changelog entries that translate technical changes into plain language
  - Audit documentation coverage and flag undocumented modules in every sprint

## Workflow

The team follows a structured flow that mirrors a real engineering sprint:

1. **Discovery** — The Architect runs a brief domain mapping session, producing a bounded context map and a first ADR capturing the high-level architecture choice.
2. **Contract-First Design** — Before any implementation, the Architect and Backend Developer agree on API contracts (OpenAPI spec). The Frontend Developer reviews these contracts and flags any gaps early.
3. **Parallel Development** — Frontend and Backend Devs build concurrently against the agreed contracts. The DB Optimizer designs the schema in parallel, producing migration files.
4. **Continuous Review** — The Code Reviewer is engaged on every pull request, not just at the end. Feedback is categorized by severity and resolved before merge.
5. **Performance Pass** — Once core features land, the DB Optimizer runs query analysis and the Frontend Developer audits Core Web Vitals. Findings feed a focused optimization sprint.
6. **Documentation Finalization** — The Technical Writer produces final API docs, runbooks, and a deployment guide before the release gate.

## Use Cases

- Building a new SaaS product from zero to first paying customer
- Rebuilding a legacy monolith as a modular system without a full rewrite
- Adding a major feature surface (e.g., a new billing module or admin dashboard) to an existing product
- Conducting a technical health assessment on an inherited codebase
- Preparing an application for a Series A due diligence engineering review
- Scaling a startup's engineering process from "two founders hacking" to a structured team workflow

## Getting Started

1. **Brief the Architect first** — Describe your domain, existing constraints, team size, and any non-negotiable technology choices. Ask for a bounded context map and an initial ADR.
2. **Review the architecture output** — Before engaging other agents, validate the architecture decisions fit your constraints. The Architect should present at least two options with trade-offs.
3. **Kick off parallel streams** — Once contracts are agreed, engage Frontend Dev, Backend Dev, and DB Optimizer simultaneously with their respective starting artifacts.
4. **Loop in Code Reviewer early** — Don't wait until the end. Run the reviewer on your first substantial PR to set quality norms for the project.
5. **Assign Technical Writer at sprint start** — Documentation written alongside code is dramatically better than documentation written after the fact.