Fullstack Dev

README

# fullstack-dev | Full-stack backend architecture and frontend-backend integration guide. Use when building a full-stack app, creating REST API with frontend, scaffolding backend service, building CRUD app, real-time app, setting up Express/React/Next.js/Node.js/Python/Go, designing service layers, error handling, config/auth, API clients, or production hardening. DO NOT trigger for pure frontend UI work or database schema only.

SKILL.md

---
name: fullstack-dev
description: |
  Full-stack backend architecture and frontend-backend integration guide. Use when building a full-stack app, creating REST API with frontend, scaffolding backend service, building CRUD app, real-time app, setting up Express/React/Next.js/Node.js/Python/Go, designing service layers, error handling, config/auth, API clients, or production hardening. DO NOT trigger for pure frontend UI work or database schema only.
license: MIT
metadata:
  category: full-stack
  version: "1.0.0"
  sources:
    - The Twelve-Factor App (12factor.net)
    - Clean Architecture (Robert C. Martin)
    - Domain-Driven Design (Eric Evans)
    - Patterns of Enterprise Application Architecture (Martin Fowler)
    - Martin Fowler (Testing Pyramid, Contract Tests)
    - Google SRE Handbook (Release Engineering)
    - ThoughtWorks Technology Radar
---

# Full-Stack Development Practices

## Router

| User intent | Operation | Output |
|---|---|---|
| scaffold new backend | SCAFFOLD_BACKEND | Apply feature-first structure and checklists from patterns |
| integrate frontend and backend | INTEGRATE | Apply API client patterns and CORS setup |
| design database layer | DB_LAYER | Apply migration, connection pooling, N+1 prevention patterns |
| add authentication/authorization | AUTH | Apply JWT/session, RBAC, refresh token flow |
| add real-time features | REAL_TIME | Setup SSE or WebSockets |
| harden for production | HARDEN | Setup global error handlers, structured logging, validation |

## Safety Boundary

Safe without confirmation:
- Reading project structure and proposing architectures.
- Generating code for new endpoints or services.

Require confirmation before:
- Modifying database schemas or running unreviewed migrations.
- Changing authentication mechanisms or secrets management.
- Overwriting existing, complex business logic.
- Executing destructive commands on the production or staging environments.

## MANDATORY WORKFLOW — Follow These Steps In Order

**When this skill is triggered, you MUST follow this workflow before writing any code.**

### Step 0: Gather Requirements

Before scaffolding anything, ask the user to clarify (or infer from context):
1. **Stack**: Language/framework for backend and frontend.
2. **Service type**: API-only, full-stack monolith, or microservice?
3. **Database**: SQL or NoSQL?
4. **Integration**: REST, GraphQL, tRPC, or gRPC?
5. **Real-time**: Needed?
6. **Auth**: Needed?

### Step 1: Architectural Decisions

Based on requirements, make and state these decisions before coding (refer to [Fullstack Patterns](references/fullstack-patterns.md)). Briefly explain each choice (1 sentence per decision).

### Step 2: Scaffold with Checklist

Use the appropriate checklist from the patterns document. Ensure ALL checked items are implemented.

### Step 3: Implement Following Patterns

Write code following the patterns in [Fullstack Patterns](references/fullstack-patterns.md). Reference specific sections as you implement each part.

### Step 4: Test & Verify

After implementation, verify build, smoke test endpoints, check integration, and real-time functions if applicable.

### Step 5: Handoff Summary

Provide a brief summary to the user detailing what was built, how to run, next steps, and key files.

## Scope

**USE this skill when:**
- Building a full-stack application (backend + frontend)
- Scaffolding a new backend service or API
- Designing service layers and module boundaries
- Implementing database access, caching, or background jobs
- Writing error handling, logging, or configuration management
- Reviewing backend code for architectural issues
- Hardening for production
- Setting up API clients, auth flows, file uploads, or real-time features

**NOT for:**
- Pure frontend/UI concerns (use your frontend framework's docs)
- Pure database schema design without backend context

## References

For detailed patterns, architecture design, and code examples, consult:
- [Fullstack Patterns](references/fullstack-patterns.md)
- [API Design](references/api-design.md)
- [Database Schema](references/db-schema.md)
- [Auth Flow](references/auth-flow.md)
- [Environment Management](references/environment-management.md)
- [Testing Strategy](references/testing-strategy.md)
- [Release Checklist](references/release-checklist.md)
- [Technology Selection](references/technology-selection.md)
- [Django Best Practices](references/django-best-practices.md)