(R) Requirements
Understanding the problem, constraints, and goals before designing
The Requirements phase is about understanding the problem deeply before jumping into solutions. This is where you ask questions, clarify constraints, and define success criteria.
Why Requirements Matter
Skipping requirements leads to:
- Over-engineering (building what you don't need)
- Under-engineering (missing critical features)
- Wrong trade-offs (optimizing the wrong things)
- Poor user experience (not meeting user needs)
Key Questions to Ask
Performance Requirements
Questions:
- What are the Core Web Vitals targets? (LCP, FID, CLS, INP)
- What's the acceptable time-to-interactive (TTI)?
- What's the target bundle size?
- What's the acceptable first contentful paint (FCP)?
Relevant Content:
- Core Web Vitals - Understanding and optimizing each metric
- Interaction to Next Paint - INP optimization
- Core Optimizations Overview - Performance fundamentals
Scale Requirements
Questions:
- How many users? (concurrent, daily, monthly)
- How many requests per second?
- How many teams will work on this?
- What's the expected growth rate?
Relevant Content:
- Microfrontends Architecture - When scale requires multiple teams
- Code Splitting Strategies - Managing bundle size at scale
- Observability - Monitoring at scale
Accessibility Requirements
Questions:
- What WCAG level? (A, AA, AAA)
- Which screen readers must be supported?
- What keyboard navigation is required?
- Are there specific legal requirements? (ADA, Section 508)
Relevant Content:
- Accessibility Patterns - Complete accessibility guide
- Screen Reader Testing - NVDA, JAWS, VoiceOver
- Color Contrast Systems - WCAG AAA compliance
- Accessible Forms - Complex form requirements
- Focus Management - SPA focus requirements
- Keyboard Shortcuts - Custom shortcuts requirements
Browser & Device Support
Questions:
- Which browsers must be supported?
- What's the minimum browser version?
- Mobile vs desktop priority?
- Do we need PWA capabilities?
Relevant Content:
- Mobile and PWA - Mobile-first requirements
- Service Worker Strategies - Offline requirements
- Performance Mobile - Mobile performance targets
Internationalization Requirements
Questions:
- How many languages?
- Do we need RTL support?
- What date/time formats?
- What number/currency formats?
Relevant Content:
- Internationalization Architecture - i18n requirements
- RTL Support - Right-to-left language requirements
- Date/Time Handling - Locale-specific formatting
- Number Formatting - Currency and unit requirements
- Pluralization Rules - Complex plural requirements
Security Requirements
Questions:
- What data needs protection?
- What's the CSP policy?
- Do we need SRI for CDN resources?
- What CORS requirements?
- Are there compliance requirements? (GDPR, HIPAA)
Relevant Content:
- Security Patterns - Security requirements overview
- Content Security Policy - CSP requirements
- Subresource Integrity - SRI requirements
- CORS Advanced - Cross-origin requirements
- Supply Chain Security - Dependency security requirements
Error Handling Requirements
Questions:
- How should errors be displayed to users?
- What error recovery is needed?
- What error monitoring is required?
- How should we handle network failures?
Relevant Content:
- Error Handling Advanced - Error handling requirements
- Error Boundary Strategies - Error isolation requirements
- Error Recovery Patterns - Recovery requirements
- Graceful Degradation - Fallback requirements
- Circuit Breaker - Resilience requirements
Rendering Strategy Requirements
Questions:
- Is SEO important?
- How dynamic is the content?
- What's the update frequency?
- Do we need real-time updates?
Relevant Content:
- Pre-rendering - SSG/SSR requirements
- Data Fetching Strategies - Data loading requirements
- Real-time Architecture - Real-time requirements
Design System Requirements
Questions:
- Do we need a design system?
- How many products/teams will use it?
- Do we need dark mode?
- What's the theming requirement?
Relevant Content:
- Design Systems - Design system requirements
- Design Tokens - Token architecture requirements
- Theming Architecture - Multi-theme requirements
- Dark Mode Implementation - Dark mode requirements
- Component API Design - API consistency requirements
Requirements Checklist
Use this checklist when gathering requirements:
Performance
- Core Web Vitals targets defined
- Bundle size budget set
- TTI target defined
- Performance budget established
Scale
- User count estimated
- Request rate estimated
- Team size considered
- Growth projections defined
Accessibility
- WCAG level determined
- Screen reader support defined
- Keyboard navigation requirements
- Legal compliance checked
Browser Support
- Browser list defined
- Minimum versions set
- Mobile priority determined
- PWA requirements defined
Internationalization
- Languages identified
- RTL support needed?
- Date/time formats defined
- Number formats defined
Security
- Data protection requirements
- CSP policy defined
- SRI requirements
- Compliance requirements
Error Handling
- Error display strategy
- Recovery mechanisms
- Monitoring requirements
- Network failure handling
Rendering
- SEO requirements
- Content dynamism
- Update frequency
- Real-time needs
Design
- Design system needed?
- Theming requirements
- Dark mode needed?
- Component consistency
Decision Framework
Simple App (Blog, Marketing)
Requirements:
- Performance: LCP < 2.5s, basic SEO
- Scale: Low traffic, single team
- Accessibility: WCAG AA
- Browser: Modern browsers only
- i18n: Single language
- Security: Basic CSPMedium App (Dashboard, SaaS)
Requirements:
- Performance: LCP < 2.5s, FID < 100ms
- Scale: Medium traffic, 2-5 teams
- Accessibility: WCAG AA, keyboard nav
- Browser: Modern + 1 version back
- i18n: 2-5 languages
- Security: Strict CSP, SRIComplex App (Social Media, E-commerce)
Requirements:
- Performance: All Web Vitals < thresholds
- Scale: High traffic, 10+ teams
- Accessibility: WCAG AAA
- Browser: Wide support
- i18n: 10+ languages, RTL
- Security: Strictest policiesCommon Mistakes
❌ Assuming requirements - Don't guess, ask
✅ Clarify everything - Better to ask than assume
❌ Ignoring constraints - "We'll optimize later"
✅ Define constraints upfront - Budget, time, team size
❌ Vague requirements - "It should be fast"
✅ Specific metrics - "LCP < 2.5s, bundle < 200KB"
❌ Skipping accessibility - "We'll add it later"
✅ Accessibility from start - Cheaper and better UX
Next Steps
After gathering requirements, move to:
- Architecture (A) - Design the system structure
- Data Model (D) - Define data flow
- Interface (I) - Design UI/UX
- Optimizations (O) - Improve performance
Remember: Good requirements lead to good architecture. Take time here—it's the foundation of everything else.