MeetingMeter - Meeting Cost Calculator

Core Data Models:

1. Users: id, email, name, organization_id, role, salary_estimate, calendar_integrations
2. Organizations: id, name, domain, subscription_tier, created_at
3. Meetings: id, external_id, title, start_time, end_time, organizer_id, recurrence_rule, source (Google/Outlook/Zoom)
4. Attendees: id, meeting_id, user_id, response_status, cost_contribution
5. CostCalculations: id, meeting_id, total_cost, calculation_time, currency
6. OptimizationInsights: id, meeting_id, insight_type, recommendation, potential_savings

Horizontal Scaling:

• Use Vercel's serverless functions for frontend API routes (automatically scales)
• Deploy backend on Railway with auto-scaling based on CPU/memory usage
• Use Supabase's managed PostgreSQL with read replicas for analytics queries

Caching:

• Redis for frequently accessed data (user sessions, meeting costs, dashboard metrics)
• CDN for static assets and report exports
• Browser caching for dashboard UI components

Database Optimization:

• Implement database indexing on frequently queried fields (user_id, organization_id, meeting_date)
• Use materialized views for common aggregations (daily/weekly meeting spend)
• Partition large tables by date ranges
• Implement query timeouts and pagination for large datasets

Cost at Scale:

Google Calendar API has strict rate limits (1,000,000 queries/day, 1,000 queries/100 seconds/user). Large organizations with many meetings could hit these limits during initial sync or peak usage times, causing data delays or missing meetings.

Impact: Incomplete meeting data leads to inaccurate cost calculations and user distrust in the system. Initial sync for large organizations could take days instead of minutes.

Mitigation Strategy:

• Batching and Caching: Implement intelligent batching of API requests to minimize calls. Cache meeting data for 24 hours to avoid re-fetching unchanged events.
• Incremental Sync: Instead of full syncs, use change tokens and webhooks to only fetch new or modified events. Google provides sync tokens for this purpose.
• Rate Limit Monitoring: Implement real-time monitoring of API usage with alerts when approaching limits. Automatically throttle requests when nearing limits.
• Fallback to Polling: When webhooks aren't available or reliable, implement smart polling that respects rate limits and user activity patterns.
• User Communication: Clearly communicate sync status and any delays to users with estimated completion times.

Contingency Plan: If rate limits are consistently hit, implement a manual CSV import option for initial sync and offer priority support for affected organizations. Consider negotiating higher rate limits with Google for enterprise customers.

Different calendar providers format event data differently. Google, Outlook, and Zoom each have their own schema for attendees, recurrence rules, time zones, and custom fields. This inconsistency makes it challenging to normalize data for consistent cost calculation and analytics.

Impact: Inaccurate cost calculations, missing meetings, or incorrect attendee information. Users lose trust in the system when data doesn't match their expectations.

Mitigation Strategy:

• Abstraction Layer: Create a provider-agnostic data model and mapping layer that converts each provider's schema to our internal format.
• Comprehensive Testing: Build a test suite with sample data from each provider covering edge cases (recurring meetings, all-day events, timezone changes).
• Data Validation: Implement validation rules to flag suspicious data (e.g., meetings with 50+ attendees, meetings longer than 8 hours).
• User Feedback Loop: Allow users to report incorrect meeting data and use this feedback to improve normalization algorithms.
• Documentation: Maintain detailed documentation of each provider's quirks and our handling approach.

Contingency Plan: If normalization issues persist, implement a manual override feature where users can correct meeting details. Prioritize fixing issues reported by paying customers.

Handling calendar data and salary information creates significant privacy and compliance risks. GDPR, CCPA, and other regulations impose strict requirements on data collection, storage, and processing. Missteps could result in legal liability, fines, or reputational damage.

Impact: Legal action, regulatory fines (up to 4% of global revenue under GDPR), loss of customer trust, and potential business shutdown in certain jurisdictions.

Mitigation Strategy:

• Privacy by Design: Build privacy considerations into every feature from the start. Conduct privacy impact assessments for new features.
• Data Minimization: Only collect and store the minimum data necessary. Use role-based salary estimates instead of individual salaries where possible.
• Transparency: Clearly communicate what data is collected, how it's used, and who has access. Provide easy-to-understand privacy policies.
• User Control: Implement granular permission levels and allow users to opt out of specific features. Provide easy data export and deletion options.
• Legal Counsel: Work with privacy lawyers to ensure compliance with all relevant regulations. Regularly review and update policies.
• Security Audits: Conduct regular security audits and penetration testing. Address vulnerabilities promptly.

Contingency Plan: If a privacy incident occurs, follow our incident response plan: contain the breach, notify affected users and authorities within required timeframes, provide credit monitoring if appropriate, and implement corrective actions to prevent recurrence.

Heavy reliance on specific third-party services (Supabase, Clerk, Vercel) creates vendor lock-in. If any of these services experience downtime, price increases, or policy changes, it could significantly impact our operations.

Impact: Service outages, unexpected cost increases, or forced migration to alternative services with significant development effort.

Mitigation Strategy:

• Abstraction Layers: Create abstraction layers for critical services (authentication, database) to make switching providers easier.
• Multi-Cloud Strategy: Design the system to be cloud-agnostic where possible. Use containerization for backend services.
• Regular Reviews: Quarterly review of vendor contracts, SLAs, and pricing. Evaluate alternatives and migration costs.
• Backup and Recovery: Implement regular backups of critical data with the ability to restore to alternative services.
• Contract Negotiation: For enterprise customers, negotiate custom SLAs and pricing to ensure stability.

Contingency Plan: Maintain a migration plan for each critical service. If a vendor becomes problematic, execute the migration plan with minimal downtime. Prioritize migrations based on business impact.

Employees may resist using MeetingMeter due to privacy concerns or perceived "Big Brother" monitoring. If adoption is low, the data will be incomplete, reducing the value for organizations.

Impact: Incomplete data leads to inaccurate insights and cost calculations. Organizations may cancel subscriptions if they don't see value.

Mitigation Strategy:

• Individual Value Proposition: Focus on how MeetingMeter helps individuals protect their time and reduce unnecessary meetings.
• Opt-in Features: Make individual tracking opt-in with clear benefits. Offer team-level aggregation by default.
• Positive Framing: Frame the product as a tool for empowerment, not surveillance. Emphasize time savings and productivity gains.
• Gamification: Add features like "meeting-free days" and personal productivity scores to make adoption engaging.
• Education: Provide resources on meeting culture and the cost of meetings to build awareness and buy-in.
• Executive Sponsorship: Work with organizational leaders to drive adoption from the top down.

Contingency Plan: If adoption is low, implement a phased rollout with pilot teams. Gather feedback and iterate on the product to address concerns. Consider making individual tracking mandatory for organizations that want the full value.

As the user base grows, database queries and analytics processing could slow down, leading to poor user experience. Complex aggregations across large datasets may exceed reasonable response times.

Impact: Slow dashboard loads frustrate users and reduce engagement. Organizations may churn if the product feels sluggish.

Mitigation Strategy:

• Database Optimization: Implement indexing on frequently queried fields, use materialized views for common aggregations, and partition large tables.
• Caching: Cache frequent queries and dashboard metrics using Redis. Implement client-side caching for static data.
• Asynchronous Processing: Move heavy computations (report generation, data aggregation) to background jobs.
• Query Optimization: Analyze and optimize slow queries. Implement query timeouts to prevent runaway queries.
• Load Testing: Regular load testing to identify and address performance bottlenecks before they affect users.
• Feature Flags: Implement feature flags to disable resource-intensive features during peak loads.

Contingency Plan: If performance degrades, implement a tiered service model where resource-intensive features are only available to higher-tier customers. Consider adding a "lite" mode for large organizations.

10-Week MVP Development Plan

• Project setup: Next.js, Express, Supabase, Prisma
• Authentication with Clerk
• Database schema design and implementation
• Basic UI framework with shadcn/ui and Tailwind
• CI/CD pipeline setup
• Error monitoring with Sentry
• Analytics setup with PostHog
• Deliverable: Working login, empty dashboard, basic navigation

• OAuth flow implementation
• Event retrieval and parsing
• Webhook setup for real-time updates
• Data normalization pipeline
• Initial sync handling
• Deliverable: Connected calendar showing raw meeting data

• Salary estimation system
• Fully-loaded cost calculation
• Meeting cost aggregation
• Database storage of cost data
• Deliverable: Basic meeting cost display

• Dashboard UI framework
• Chart implementation with Recharts
• Time period filtering
• Basic optimization insights
• Deliverable: Functional analytics dashboard with cost data

• UI/UX refinement based on user feedback
• Error handling and edge cases
• Performance optimization
• Security hardening
• Accessibility audit
• Cross-browser testing
• Load testing and optimization
• Privacy compliance review
• Deliverable: Beta-ready product with polished UI and robust error handling

• User testing with pilot customers
• Bug fixes based on feedback
• Analytics and monitoring setup
• Documentation (user guides, API docs)
• Marketing website updates
• Pricing page implementation
• Stripe integration for billing
• Onboarding flow optimization
• Deliverable: Production-ready v1.0 with complete documentation and billing

• Week 2: Finalize database schema - changes after this point will be costly
• Week 4: Calendar integration review - decide whether to proceed with Outlook/Zoom or focus on Google
• Week 6: Analytics dashboard review - validate that the data presentation meets user needs
• Week 8: Go/no-go decision for beta launch based on testing results
• Week 10: Final launch readiness review