StillOnTime is a cutting-edge film industry logistics application that revolutionizes how production crews manage schedules, routes, and equipment logistics. Built with performance-first principles, it delivers 75% faster database queries, 70% faster API responses, and 43% smaller bundle sizes.

• 🎬 Automated Email Processing - Monitors Gmail for shooting schedule emails with PDF attachments
• 🗺️ Intelligent Route Planning - Calculates optimal routes with real-time traffic data
• 📅 Google Calendar Integration - Creates calendar events with multiple alarms
• 🌤️ Weather Integration - Provides forecasts and warnings for outdoor shoots
• 📱 React Dashboard - Modern web interface for monitoring and configuration
• 🔒 OAuth 2.0 Security - Secure Google services integration
• ⚡ Performance Optimized - Advanced caching, monitoring, and optimization

• Node.js 20+
• PostgreSQL 15+
• Redis 7+
• Docker (optional)
• Google Cloud Console project with APIs enabled
• OpenWeatherMap API key

# Clone the repository
git clone https://github.com/stillontime/stillontime.git
cd stillontime

# Install all dependencies
npm run install:all

# Setup environment variables
npm run setup:env

# Setup database
npm run prisma:generate
npm run prisma:migrate

# Build the application
npm run build

# Start development servers
npm run dev

# Start all services with Docker
docker-compose up -d

# View logs
docker-compose logs -f

# Stop services
docker-compose down

For a minimal deployment path using Vercel for the frontend and Supabase Postgres for the database, see the Vercel + Supabase Deployment (Minimal) section in the deployment guide.

# Setup performance monitoring
npm run setup:performance

# Install monitoring tools
npm run monitoring:setup

# Run performance tests
npm run test:performance:ci

• Grafana Dashboard: http://localhost:3000/d/performance
• Metrics Endpoint: http://localhost:3001/metrics
• Health Check: http://localhost:3001/health

• JavaScript Bundle: < 500KB gzipped
• CSS Bundle: < 50KB gzipped
• Total Bundle: < 1MB gzipped
• API Response: < 200ms average
• Lighthouse Score: > 90

# Run all tests
npm test

# Run performance tests
npm run test:performance

# Run end-to-end tests
npm run test:e2e

# Run load tests
npm run test:api-performance

# Check performance budgets
npm run performance:budget-check

# Bundle analysis
npm run performance:bundle

# Lighthouse testing
npm run test:lighthouse

# API load testing
npm run test:api-performance

# Regression analysis
npm run performance:regression-check

StillOnTime/
├── 🎬 backend/                 # Node.js/Express API
│   ├── src/                   # Source code
│   ├── tests/                 # Backend tests
│   └── migrations/            # Database migrations
├── 🎨 frontend/               # React/Vite frontend
│   ├── src/                   # Source code
│   ├── tests/                 # Frontend tests
│   └── public/                # Static assets
├── 📊 monitoring/             # Performance monitoring
├── 🐳 docker/                # Docker configurations
├── 📚 docs/                  # Documentation
└── 🔧 scripts/               # Build and utility scripts

• 📖 Performance Optimization Guide
• 👥 Development Guide (AGENTS.md) - Key project patterns and workflows
• ⚙️ Claude Code Configuration (CLAUDE.md) - AI development environment setup
• 🔒 Privacy Policy

• 🔧 API Documentation
• 🚀 Deployment Guide
• 🔒 Security Guide
• 📊 Monitoring Guide
• 📋 Admin Manual
• 🔍 Architecture Analysis Report - Comprehensive codebase analysis

• 📐 Architecture Documentation - System architecture and design
• 📝 SPARC Specifications - Complete system specifications
• 🗂️ Historical Documentation - Archived session summaries and reports

# Database
DATABASE_URL="postgresql://user:password@localhost:5432/stillontime_automation"
REDIS_URL="redis://localhost:6379"

# Google OAuth 2.0
GOOGLE_CLIENT_ID="your-google-client-id"
GOOGLE_CLIENT_SECRET="your-google-client-secret"
GOOGLE_REDIRECT_URI="http://localhost:3000/auth/callback"

# External APIs
OPENWEATHER_API_KEY="your-openweather-api-key"
GOOGLE_MAPS_API_KEY="your-google-maps-api-key"

# Application
JWT_SECRET="your-jwt-secret"
NODE_ENV="development"
PORT="3001"
FRONTEND_URL="http://localhost:3000"

1. Enable required APIs:

   • Gmail API
   • Google Calendar API
   • Google Drive API
   • Google Maps API

2. OAuth 2.0 Scopes:

   • https://www.googleapis.com/auth/gmail.readonly
   • https://www.googleapis.com/auth/calendar
   • https://www.googleapis.com/auth/drive.file

1. Authentication: Sign in with your Google account
2. Configuration: Set up your home address, Panavision address, and time buffers
3. Email Monitoring: The system automatically monitors your Gmail for schedule emails
4. Processing: When a schedule email is detected, it:
   • Downloads and parses the PDF attachment
   • Calculates optimal routes with traffic data
   • Fetches weather forecasts
   • Creates calendar events with alarms
   • Sends notifications

# Development
npm run dev              # Start all development servers
npm run build            # Build for production
npm run test             # Run all tests

# Performance
npm run test:performance # Run performance test suite
npm run performance:bundle # Analyze bundle size
npm run performance:budget-check # Check performance budgets
npm run monitoring:start # Start monitoring services

# Database
npm run prisma:migrate   # Run database migrations
npm run prisma:studio    # Open Prisma Studio
npm run prisma:migrate:performance # Apply performance indexes

# Docker
npm run docker:up       # Start all services
npm run docker:down     # Stop all services
npm run docker:logs     # View logs

1. Create feature branch from main
2. Implement changes with performance considerations
3. Run performance tests: npm run test:performance
4. Check performance budgets: npm run performance:budget-check
5. Submit pull request with performance metrics

• Monitor bundle size impact
• Test API performance changes
• Consider database query optimization
• Implement caching where appropriate
• Follow performance budgets

• Performance Testing: Automated on every PR
• Budget Checking: Enforces performance budgets
• Load Testing: Validates API performance under load
• Regression Detection: Identifies performance regressions
• Dashboard Updates: Updates performance metrics

1. Build: Optimized build with bundle analysis
2. Test: Unit, integration, and performance tests
3. Performance: Lighthouse, load testing, budget checks
4. Deploy: Automated deployment to staging/production
5. Monitor: Performance tracking and alerting

• Slow API Responses: Check database query performance
• High Memory Usage: Review cache configuration
• Bundle Size Increases: Analyze with bundle analyzer
• Frontend Performance: Check Web Vitals metrics

• Database Optimization: Add indexes, optimize queries
• Cache Tuning: Adjust TTL and cache strategies
• Bundle Optimization: Implement code splitting
• Resource Scaling: Increase system resources

For questions and support:

• GitHub Issues: Create an issue
• Performance Team: performance@stillontime.com
• Documentation: StillOnTime Docs

This project is licensed under the MIT License - see the LICENSE file for details.