Skip to main content

Architecture Overview

LyfeAI Provider is built with Next.js 14 and demonstrates a modern healthcare application architecture.

⚠️ Current State: This document describes both the implemented architecture and aspirational design. Many backend services shown are simulated or partially implemented.

Current Architecture​

┌─────────────────────────────────────────────────────────────┐
│                    Frontend (Next.js 14)                      │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐   │
│  │   App Dir   │  │  Components  │  │   shadcn/ui     │   │
│  │   Pages     │  │  (UI Heavy)  │  │  Components     │   │
│  └─────────────┘  └──────────────┘  └──────────────────┘   │
└─────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                 Server Actions (Mixed Reality)                │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐   │
│  │  Patient    │  │      AI      │  │ Communication    │   │
│  │  Actions    │  │   Actions    │  │   Actions        │   │
│  │  ✅ Real    │  │  ✅ Real     │  │  🎨 Mock        │   │
│  └─────────────┘  └──────────────┘  └──────────────────┘   │
└─────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                    Data Layer (Hybrid)                        │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐   │
│  │  Supabase   │  │  Mock Data   │  │   localStorage   │   │
│  │  Database   │  │  (lib/data)  │  │     Auth         │   │
│  │  ✅ Real    │  │  🎨 Static   │  │   🎨 Mock       │   │
│  └─────────────┘  └──────────────┘  └──────────────────┘   │
└─────────────────────────────────────────────────────────────┘

Implementation Status​

✅ Fully Implemented​

  • Next.js App Router - All pages use app directory
  • Server Components - Default for all pages
  • PostgreSQL Database - 5 tables via Supabase
  • AI Service - OpenAI integration with fallback
  • FHIR Parser - Complete patient bundle parsing

🟨 Partially Implemented​

  • Server Actions - Some real, many return mock data
  • Authentication - Mock system with localStorage
  • Role-Based Access - UI respects roles, no backend enforcement

🎨 UI Only (Mock Implementation)​

  • Real-time Features - No WebSocket implementation
  • Communication - UI exists, no messaging backend
  • Analytics - Charts with static data
  • Scheduling - UI only, no calendar system

❌ Not Implemented​

  • Security Layer - No real authentication/authorization
  • File Storage - No document upload backend
  • External Integrations - No EHR/lab connections
  • Message Queue - No async job processing

Actual Data Flow​

1. Patient Management (Real)​

User Input → Server Action → Supabase → Database → UI Update

2. AI Processing (Real with Fallback)​

Document Upload → AI Service → OpenAI API (or Simulation) → Structured Data

3. Communication (Mock)​

User Action → Server Action → Mock Response → UI Update (no persistence)

Current Tech Stack​

Core​

  • Framework: Next.js 14.2.16 (App Router)
  • UI: React 18, Tailwind CSS, shadcn/ui
  • Language: TypeScript (with some any types)

Backend Services​

  • Database: PostgreSQL via Supabase (when configured)
  • AI: OpenAI GPT-4 (optional, falls back to simulation)
  • Auth: Mock localStorage system

Not Implemented​

  • Real authentication provider
  • File storage service
  • Email/SMS services
  • Video conferencing
  • Payment processing

Security Architecture (Current State)​

⚠️ NOT PRODUCTION READY

What Exists​

  • Basic role definitions in code
  • UI-level permission checks
  • Supabase RLS policies (may not be enforced)

What's Missing​

  • Real authentication
  • Session management
  • API security
  • Data encryption
  • Audit logging
  • HIPAA compliance

Development vs Production Gaps​

Current (Development)​

// Mock auth
localStorage.setItem('currentUser', JSON.stringify(user));

// Mock data
return { success: true, data: mockData };

// No error handling
const result = await action();

Required for Production​

// Real auth
const session = await auth.createSession(credentials);

// Real database
const { data, error } = await db.query(sql);

// Proper error handling
try {
  const result = await action();
  await audit.log(action, user, result);
  return result;
} catch (error) {
  await monitoring.alert(error);
  return handleError(error);
}

Scalability Considerations​

What Works Now​

  • Stateless architecture (ready for horizontal scaling)
  • Database connection pooling (via Supabase)
  • Static asset optimization

What's Needed​

  • Caching layer (Redis)
  • Queue system for async tasks
  • CDN configuration
  • Load balancing
  • Database optimization

Architecture Decisions​

Why This Stack?​

  1. Next.js 14 - Modern React features, good DX
  2. Supabase - Quick PostgreSQL setup with built-in features
  3. shadcn/ui - Beautiful components without heavy dependencies
  4. TypeScript - Type safety (though not strictly enforced)

Trade-offs Made​

  1. Mock Auth - Faster development, but not secure
  2. Mixed Implementation - Can demo all features, but confusing
  3. UI-First - Looks complete, but limited functionality
  4. Minimal Backend - Quick to build, but not production-ready

Next Steps for Production​

  1. Replace Mock Systems

    • Implement real authentication
    • Replace mock data with real services
    • Add proper error handling

  2. Add Missing Infrastructure

    • File storage service
    • Message queue
    • Caching layer
    • Monitoring/logging

  3. Security Hardening

    • Implement all security layers
    • Add encryption
    • Enable audit logging
    • HIPAA compliance

  4. Performance Optimization

    • Add caching strategies
    • Optimize database queries
    • Implement lazy loading
    • Add CDN

Summary​

The current architecture is:

  • ✅ Good for demos - Shows the vision
  • ✅ Developer friendly - Easy to understand and extend
  • ❌ Not production ready - Many critical pieces missing
  • 🔄 Upgradeable - Good foundation to build upon

See Current State Summary for more details on implementation status.