Full Stack Orchestration Full Stack Feature

1---
2name: full-stack-orchestration-full-stack-feature
3description: "Use when working with full stack orchestration full stack feature"
4---
5 
6## Use this skill when
7 
8- Working on full stack orchestration full stack feature tasks or workflows
9- Needing guidance, best practices, or checklists for full stack orchestration full stack feature
10 
11## Do not use this skill when
12 
13- The task is unrelated to full stack orchestration full stack feature
14- You need a different domain or tool outside this scope
15 
16## Instructions
17 
18- Clarify goals, constraints, and required inputs.
19- Apply relevant best practices and validate outcomes.
20- Provide actionable steps and verification.
21- If detailed examples are required, open `resources/implementation-playbook.md`.
22 
23Orchestrate full-stack feature development across backend, frontend, and infrastructure layers with modern API-first approach:
24 
25[Extended thinking: This workflow coordinates multiple specialized agents to deliver a complete full-stack feature from architecture through deployment. It follows API-first development principles, ensuring contract-driven development where the API specification drives both backend implementation and frontend consumption. Each phase builds upon previous outputs, creating a cohesive system with proper separation of concerns, comprehensive testing, and production-ready deployment. The workflow emphasizes modern practices like component-driven UI development, feature flags, observability, and progressive rollout strategies.]
26 
27## Phase 1: Architecture & Design Foundation
28 
29### 1. Database Architecture Design
30- Use Task tool with subagent_type="database-design::database-architect"
31- Prompt: "Design database schema and data models for: $ARGUMENTS. Consider scalability, query patterns, indexing strategy, and data consistency requirements. Include migration strategy if modifying existing schema. Provide both logical and physical data models."
32- Expected output: Entity relationship diagrams, table schemas, indexing strategy, migration scripts, data access patterns
33- Context: Initial requirements and business domain model
34 
35### 2. Backend Service Architecture
36- Use Task tool with subagent_type="backend-development::backend-architect"
37- Prompt: "Design backend service architecture for: $ARGUMENTS. Using the database design from previous step, create service boundaries, define API contracts (OpenAPI/GraphQL), design authentication/authorization strategy, and specify inter-service communication patterns. Include resilience patterns (circuit breakers, retries) and caching strategy."
38- Expected output: Service architecture diagram, OpenAPI specifications, authentication flows, caching architecture, message queue design (if applicable)
39- Context: Database schema from step 1, non-functional requirements
40 
41### 3. Frontend Component Architecture
42- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
43- Prompt: "Design frontend architecture and component structure for: $ARGUMENTS. Based on the API contracts from previous step, design component hierarchy, state management approach (Redux/Zustand/Context), routing structure, and data fetching patterns. Include accessibility requirements and responsive design strategy. Plan for Storybook component documentation."
44- Expected output: Component tree diagram, state management design, routing configuration, design system integration plan, accessibility checklist
45- Context: API specifications from step 2, UI/UX requirements
46 
47## Phase 2: Parallel Implementation
48 
49### 4. Backend Service Implementation
50- Use Task tool with subagent_type="python-development::python-pro" (or "golang-pro"/"nodejs-expert" based on stack)
51- Prompt: "Implement backend services for: $ARGUMENTS. Using the architecture and API specs from Phase 1, build RESTful/GraphQL endpoints with proper validation, error handling, and logging. Implement business logic, data access layer, authentication middleware, and integration with external services. Include observability (structured logging, metrics, tracing)."
52- Expected output: Backend service code, API endpoints, middleware, background jobs, unit tests, integration tests
53- Context: Architecture designs from Phase 1, database schema
54 
55### 5. Frontend Implementation
56- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
57- Prompt: "Implement frontend application for: $ARGUMENTS. Build React/Next.js components using the component architecture from Phase 1. Implement state management, API integration with proper error handling and loading states, form validation, and responsive layouts. Create Storybook stories for components. Ensure accessibility (WCAG 2.1 AA compliance)."
58- Expected output: React components, state management implementation, API client code, Storybook stories, responsive styles, accessibility implementations
59- Context: Component architecture from step 3, API contracts
60 
61### 6. Database Implementation & Optimization
62- Use Task tool with subagent_type="database-design::sql-pro"
63- Prompt: "Implement and optimize database layer for: $ARGUMENTS. Create migration scripts, stored procedures (if needed), optimize queries identified by backend implementation, set up proper indexes, and implement data validation constraints. Include database-level security measures and backup strategies."
64- Expected output: Migration scripts, optimized queries, stored procedures, index definitions, database security configuration
65- Context: Database design from step 1, query patterns from backend implementation
66 
67## Phase 3: Integration & Testing
68 
69### 7. API Contract Testing
70- Use Task tool with subagent_type="test-automator"
71- Prompt: "Create contract tests for: $ARGUMENTS. Implement Pact/Dredd tests to validate API contracts between backend and frontend. Create integration tests for all API endpoints, test authentication flows, validate error responses, and ensure proper CORS configuration. Include load testing scenarios."
72- Expected output: Contract test suites, integration tests, load test scenarios, API documentation validation
73- Context: API implementations from Phase 2
74 
75### 8. End-to-End Testing
76- Use Task tool with subagent_type="test-automator"
77- Prompt: "Implement E2E tests for: $ARGUMENTS. Create Playwright/Cypress tests covering critical user journeys, cross-browser compatibility, mobile responsiveness, and error scenarios. Test feature flags integration, analytics tracking, and performance metrics. Include visual regression tests."
78- Expected output: E2E test suites, visual regression baselines, performance benchmarks, test reports
79- Context: Frontend and backend implementations from Phase 2
80 
81### 9. Security Audit & Hardening
82- Use Task tool with subagent_type="security-auditor"
83- Prompt: "Perform security audit for: $ARGUMENTS. Review API security (authentication, authorization, rate limiting), check for OWASP Top 10 vulnerabilities, audit frontend for XSS/CSRF risks, validate input sanitization, and review secrets management. Provide penetration testing results and remediation steps."
84- Expected output: Security audit report, vulnerability assessment, remediation recommendations, security headers configuration
85- Context: All implementations from Phase 2
86 
87## Phase 4: Deployment & Operations
88 
89### 10. Infrastructure & CI/CD Setup
90- Use Task tool with subagent_type="deployment-engineer"
91- Prompt: "Setup deployment infrastructure for: $ARGUMENTS. Create Docker containers, Kubernetes manifests (or cloud-specific configs), implement CI/CD pipelines with automated testing gates, setup feature flags (LaunchDarkly/Unleash), and configure monitoring/alerting. Include blue-green deployment strategy and rollback procedures."
92- Expected output: Dockerfiles, K8s manifests, CI/CD pipeline configs, feature flag setup, IaC templates (Terraform/CloudFormation)
93- Context: All implementations and tests from previous phases
94 
95### 11. Observability & Monitoring
96- Use Task tool with subagent_type="deployment-engineer"
97- Prompt: "Implement observability stack for: $ARGUMENTS. Setup distributed tracing (OpenTelemetry), configure application metrics (Prometheus/DataDog), implement centralized logging (ELK/Splunk), create dashboards for key metrics, and define SLIs/SLOs. Include alerting rules and on-call procedures."
98- Expected output: Observability configuration, dashboard definitions, alert rules, runbooks, SLI/SLO definitions
99- Context: Infrastructure setup from step 10
100 
101### 12. Performance Optimization
102- Use Task tool with subagent_type="performance-engineer"
103- Prompt: "Optimize performance across stack for: $ARGUMENTS. Analyze and optimize database queries, implement caching strategies (Redis/CDN), optimize frontend bundle size and loading performance, setup lazy loading and code splitting, and tune backend service performance. Include before/after metrics."
104- Expected output: Performance improvements, caching configuration, CDN setup, optimized bundles, performance metrics report
105- Context: Monitoring data from step 11, load test results
106 
107## Configuration Options
108- `stack`: Specify technology stack (e.g., "React/FastAPI/PostgreSQL", "Next.js/Django/MongoDB")
109- `deployment_target`: Cloud platform (AWS/GCP/Azure) or on-premises
110- `feature_flags`: Enable/disable feature flag integration
111- `api_style`: REST or GraphQL
112- `testing_depth`: Comprehensive or essential
113- `compliance`: Specific compliance requirements (GDPR, HIPAA, SOC2)
114 
115## Success Criteria
116- All API contracts validated through contract tests
117- Frontend and backend integration tests passing
118- E2E tests covering critical user journeys
119- Security audit passed with no critical vulnerabilities
120- Performance metrics meeting defined SLOs
121- Observability stack capturing all key metrics
122- Feature flags configured for progressive rollout
123- Documentation complete for all components
124- CI/CD pipeline with automated quality gates
125- Zero-downtime deployment capability verified
126 
127## Coordination Notes
128- Each phase builds upon outputs from previous phases
129- Parallel tasks in Phase 2 can run simultaneously but must converge for Phase 3
130- Maintain traceability between requirements and implementations
131- Use correlation IDs across all services for distributed tracing
132- Document all architectural decisions in ADRs
133- Ensure consistent error handling and API responses across services
134 
135Feature to implement: $ARGUMENTS
136