How It's Built

Why Next.js 14+

Hybrid rendering (SSR + SSG) ensures optimal SEO for professional profile pages while maintaining fast performance. Built-in API routes eliminate the need for a separate backend server, simplifying deployment and reducing infrastructure costs. Automatic code splitting and image optimization handle performance concerns out of the box, allowing focus on building features rather than configuration.

Why React 18

Component-based architecture enables reusability across pages (e.g., RotatingBackground used in multiple sections), accelerating development. The massive ecosystem provides battle-tested solutions for complex features like the Ken Burns slideshow and chatbot interface. Declarative nature makes the codebase maintainable for future enhancements.

Why TypeScript

Catches errors at compile time rather than runtime, critical for features like calendar integration where incorrect data types could cause booking failures. IDE autocomplete and type checking accelerate development of complex features (chatbot, RAG integration). Self-documenting code makes the codebase maintainable despite its growing complexity.

Why Tailwind CSS

Utility-first approach ensures perfect visual consistency for the editorial aesthetic across all pages without CSS specificity battles. JIT compiler keeps bundle size minimal despite extensive styling. Rapid iteration on design changes without creating conflicting CSS rules. Ideal for achieving the precise, high-contrast monochromatic look required.

Why Pure CSS Animations

GPU-accelerated CSS animations provide smooth 60fps performance for the hero slideshow without JavaScript overhead. Simpler and more performant than animation libraries like Framer Motion for these specific use cases. Reduces bundle size while maintaining visual polish essential for the editorial aesthetic.

Why Next.js API Routes

Seamless integration with the frontend eliminates the complexity of managing separate backend servers. Single deployment simplifies the architecture while serverless functions provide automatic scaling. Perfect for this use case where API needs are moderate and co-location accelerates development.

Why Google Calendar API

Direct API integration eliminates third-party scheduling costs (vs. Calendly) while providing full control over the user experience. Service account authentication enables seamless server-side access. Reliable Google infrastructure ensures meeting invitations always reach attendees.

Why Google Gemini AI

Superior integration with Google Calendar for seamless meeting scheduling. Context caching reduces API costs by ~90% for the frequently-used professional background context. Function calling enables tool use (calendar, RAG search) while maintaining natural conversation flow. Strong performance on professional queries makes it ideal for this use case.

Why RAG Backend (Python/FastAPI)

Python's dominant AI/ML ecosystem (LangChain, ChromaDB) makes it the pragmatic choice despite being a different language from the frontend. FastAPI provides automatic API documentation and validation. Superior libraries for document processing and embeddings reduce development time significantly compared to Node.js alternatives. Adaptive retrieval ensures comprehensive answers without wasting API calls.

Why ChromaDB Vector Store

Embedded database eliminates the need for separate cloud services (vs. Pinecone) and operating costs. Simple setup and maintenance with persistent local storage. Performance is excellent at this scale (~100 documents). Perfect for this project where massive scale isn't required but semantic search is essential.

Why Redis (Session Store)

Critical for production deployment - prevents session loss during server restarts (unacceptable UX). Automatic TTL expiry eliminates manual cleanup of expired sessions and OTP codes. Supports horizontal scaling if traffic grows. Persistence support (vs. Memcached) ensures reliability. Gracefully falls back to in-memory storage if unavailable.

Why File-based JSON Storage

Low data volume doesn't justify database complexity and hosting costs. Git-friendly backups and version control. Simpler deployment without database credentials or connection management. Performance is excellent for this scale (< 1000 records). Easy migration path to a database if scale demands it.