SlugMatch Sprint Tickets (1 Month Timeline)

Sprint 1 (Weeks 1-2): Foundation & Core Quiz Functionality

Backend Foundation (Developer A)

SCRUM-1: Initialize Node.js/Express server with JavaScript

Set up Express server with basic middleware (cors, helmet, morgan)
Configure JavaScript build process and development setup
Add basic project structure and folder organization
Set up development and production environment configurations
Configure ESLint and Prettier for JavaScript code quality

SCRUM-2: Configure MongoDB connection with Mongoose

Set up Mongoose connection with proper error handling
Configure connection pooling and retry logic
Add environment variables for database connection
Create database connection utility functions

SCRUM-3: Create questions database schema and model

Implement the provided question schema with all college weights
Add validation rules and indexes for performance
Create Mongoose model with proper TypeScript types
Add schema validation for all question types (range, yes_no, multiple_choice, text)

SCRUM-4: Set up basic API structure and middleware

Create API route structure and organization
Set up request/response middleware
Add API versioning and documentation structure
Prepare for additional API endpoints

SCRUM-5: Build GET /api/questions endpoint

Implement endpoint to fetch all questions from database
Add proper error handling and response formatting
Include question ordering by index
Add basic API documentation

SCRUM-6: Build POST /api/questions endpoint

Create endpoint for adding new questions
Add validation for question schema compliance
Implement proper error handling for duplicate indexes
Add success/failure response formatting

SCRUM-7: Build PUT /api/questions/:index endpoint

Implement question update functionality
Add validation for existing question index
Handle partial updates and schema validation
Add proper error responses

SCRUM-8: Build DELETE /api/questions/:index endpoint

Implement question deletion functionality
Add validation for question existence
Handle cascade effects and data integrity
Add confirmation responses

SCRUM-9: Add comprehensive API error handling

Create global error handling middleware
Implement standardized error response format
Add logging for debugging and monitoring
Handle different error types (validation, database, server)

SCRUM-10: Create /health endpoint for monitoring

Implement health check endpoint
Add database connection status check
Include server uptime and basic metrics
Prepare for production monitoring

Frontend Foundation (Developer B)

SCRUM-11: Set up TanStack Router with /quiz route

Configure TanStack Router with proper route structure
Set up /quiz route with basic component structure
Add route guards and navigation utilities
Configure route-based code splitting

SCRUM-12: Create basic Quiz component structure

Build Quiz component with info page and quiz state
Implement basic state management for quiz progress
Add navigation between quiz info and actual quiz
Create responsive layout structure

SCRUM-13: Set up TanStack Query for API integration

Configure TanStack Query client with proper defaults
Set up query keys and cache management
Add error handling and retry logic
Prepare for questions API integration

SCRUM-14: Create ProgressBar component with milestone indicators

Build progress bar with 15/30/50 milestone markers
Add visual feedback for milestone achievements
Implement progress calculation logic
Create responsive design for different screen sizes

SCRUM-15: Create Question component structure

Build reusable Question component for all question types
Add support for range, yes_no, multiple_choice, and text inputs
Implement answer validation and selection logic
Create smooth transitions between questions

SCRUM-16: Add basic answer options display

Implement answer rendering for different question types
Add proper styling and interaction states
Create accessibility features (keyboard navigation, ARIA labels)
Add answer selection feedback

SCRUM-17: Implement progress calculation logic

Create progress tracking state management
Add milestone achievement detection
Implement “End Quiz” button logic after 15 questions
Add progress persistence during quiz session

SCRUM-18: Create quiz state management system

Implement comprehensive quiz state with React hooks
Add state persistence for quiz progress
Create state reset and cleanup functions
Add state validation and error handling

SCRUM-19: Set up basic error handling and loading states

Add error boundaries for React components
Implement loading states for API calls
Create user-friendly error messages
Add retry mechanisms for failed operations

SCRUM-20: Add basic styling and responsive design

Implement consistent design system with existing components
Add responsive breakpoints for mobile/tablet/desktop
Create loading skeletons and transition animations
Ensure accessibility compliance

Sprint 2 (Weeks 3-4): Results, College Pages & Launch

Backend Tickets (Developer A)

SCRUM-21: Set up results storage schema and validation

Create results schema for storing user quiz completion data
Add validation for result data structure
Prepare for storing quiz results when users complete the quiz
Note: All calculations are done on frontend, backend only stores results

SCRUM-22: Build POST /api/results endpoint

Create results schema (quizId, answers, completedAt, questionsAnswered)
Implement result saving logic for when user confirms quiz completion
Add basic validation for result data
Only called when user presses “Yes” on end quiz confirmation
Note: No college information stored - only user answers and completion data
College names/descriptions are all client-side, not stored in backend

SCRUM-23: Add GET /api/results/:id endpoint

Create endpoint to retrieve specific quiz result by ID
Add error handling for non-existent results
Return result data in consistent format

SCRUM-24: Implement PostHog analytics integration

Set up PostHog tracking for quiz events
Add tracking for page views, quiz completions, milestone achievements
Implement college result click tracking

SCRUM-25: Add comprehensive error handling and security

Add global error handling middleware
Create standardized error response format
Add logging for debugging and monitoring
Implement rate limiting for API endpoints
Add CORS configuration for production

SCRUM-26: Set up production deployment pipeline

Configure Vercel deployment for backend
Set up environment variables and secrets
Add health check endpoint for monitoring
Optimize database performance and indexing

Frontend Tickets (Developer B)

SCRUM-27: Build Question component with answer handling

Create reusable Question component for all question types (range, yes_no, multiple_choice, text)
Implement answer selection and validation logic
Add smooth transitions between questions
Trigger real-time score calculations on each answer

SCRUM-28: Implement ProgressBar with milestone indicators

Create progress bar component with 15/30/50 milestone markers
Add visual feedback for milestone achievements
Implement progress calculation and display

SCRUM-29: Add quiz state management with TanStack Query

Set up TanStack Query for API calls (only for saving results)
Implement quiz session state management with real-time calculations
Add real-time score tracking and college ranking updates
Only make API calls when user confirms quiz completion

SCRUM-30: Create “End Quiz” modal with confirmation

Build modal component for quiz completion confirmation
Add logic to show modal after 15 questions
Implement “Yes” button that triggers POST /api/results and navigation to results page
Implement “No” button that closes modal and continues quiz

SCRUM-31: Create client-side college data structure

Design college information data structure (name, description, pros, cons, tips, faqs)
Create seed data for all 10 UCSC colleges as client-side constants
Organize college data for easy access in frontend components
Note: This is the ONLY place college information is stored - not in backend

SCRUM-32: Build Results page with top 5 colleges

Create results display component showing top 5 matches
Add college cards with basic information from client-side data and “Learn More” buttons
Implement responsive design for results layout
Note: All college information comes from client-side constants, not backend

SCRUM-33: Create individual college detail pages

Build college detail page component with full information from client-side data
Add sections for pros/cons, tips, and FAQs using local college data
Implement smooth navigation and back button
Note: All college information is stored in client-side constants, not fetched from backend

SCRUM-34: Add PostHog tracking to frontend

Integrate PostHog client-side tracking
Add event tracking for quiz interactions
Implement page view tracking across all routes

SCRUM-35: Implement comprehensive error handling and loading states

Add error boundaries for React components
Create user-friendly error messages
Add retry mechanisms for failed API calls
Implement loading states for all async operations
Create skeleton screens for better perceived performance

SCRUM-36: Final testing, optimization and deployment

Conduct comprehensive testing across all features
Fix any remaining bugs and edge cases
Optimize performance and accessibility
Add lazy loading for components and routes
Implement proper ARIA labels and keyboard navigation
Optimize bundle size and loading performance
Deploy to production

Additional API Routes for Results

PostHog Implementation Recommendations

Easy PostHog Setup:

Track page views automatically
Track quiz completion events
Track which milestone users reach (15/30/50)
Track college result clicks

Database Schema

Questions Schema:

 
const questionSchema = new mongoose.Schema({
 
index: { type: Number, required: true, unique: true },
 
type: { type: String, required: true, enum: ["range", "yes_no", "multiple_choice", "text"] },
 
questionContent: { type: String, required: true },
 
answers: [{
 
text: { type: String, required: true },
 
weights: {
 
oakes: { type: Number, required: true, default: 0 },
 
rachel_carson: { type: Number, required: true, default: 0 },
 
crown: { type: Number, required: true, default: 0 },
 
merrill: { type: Number, required: true, default: 0 },
 
porter: { type: Number, required: true, default: 0 },
 
kresge: { type: Number, required: true, default: 0 },
 
stevenson: { type: Number, required: true, default: 0 },
 
cowell: { type: Number, required: true, default: 0 },
 
college_nine: { type: Number, required: true, default: 0 },
 
john_r_lewis: { type: Number, required: true, default: 0 }
 
}
 
}]
 
}, { timestamps: true });

Technology Stack

Backend:

JavaScript + Express + Mongoose
MongoDB for database
Vercel for deployment

Frontend:

TypeScript + React + TanStack Router + TanStack Query
shadcn/ui components
Framer Motion for animations
PostHog for analytics

Sprint Dependencies (1 Month Timeline)

Cross-Sprint Dependencies:

Sprint 1 backend APIs must be ready before Sprint 2 frontend integration
PostHog setup in Sprint 2 backend should be completed before frontend integration
College data structure in Sprint 2 should be completed before college detail pages

Parallel Work Opportunities:

Backend API development can happen in parallel with frontend component development
Database schema design can be done early and shared between developers
UI/UX design decisions can be made independently of backend logic

Risk Mitigation:

Start with simple implementations and iterate
Test API endpoints early with tools like Postman
Use feature flags for gradual rollout of new features
Keep database migrations simple and reversible
Focus on MVP features first, polish later

Ivan's Cool Obsidian Vault

Explorer