Somnia: AI-Powered Dream Journal

Joel Brown | Sep 20, 2024 min read
Somnia: AI-Powered Dream Journal

Somnia: When Dreams Meet AI

Ever wondered what your dreams actually mean? As a 27-year-old engineering student fascinated by the intersection of AI and human psychology, I built Somnia - a modern Flutter dream journal that uses AI to unlock the hidden patterns in your subconscious mind.

This isn’t just another note-taking app. It’s a complete system that combines dream logging, AI-powered analysis, and freemium monetization into a polished mobile experience.

The Problem I Wanted to Solve

During my time at Digicel, I learned the value of data analysis and pattern recognition in network systems. I got curious: what if we could apply similar analytical approaches to something as personal and mysterious as dreams?

Traditional dream journals are just text dumps. You write, you forget, you never really understand the patterns. I wanted something smarter - an app that could:

  • Track dreams with rich metadata (mood, lucidity, themes)
  • Analyze patterns using AI
  • Provide actionable insights for lucid dreaming
  • Actually help users understand their subconscious minds

The Complete System Architecture

Frontend: Modern Flutter with Riverpod

Somnia is built with Flutter, using the latest Material Design 3 principles and sophisticated state management:

// Clean, type-safe state management with Riverpod
final dreamProvider = StateNotifierProvider<DreamNotifier, AsyncValue<List<Dream>>>(
  (ref) => DreamNotifier(ref.read(supabaseServiceProvider))
);

// Real-time UI updates with proper loading states
class DreamListScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final dreamsAsync = ref.watch(dreamProvider);

    return dreamsAsync.when(
      loading: () => const LottieLoadingWidget(),
      error: (error, stack) => ErrorWidget(error.toString()),
      data: (dreams) => DreamListView(dreams: dreams),
    );
  }
}

Key Features:

  • Material Design 3 with custom dream-themed color palette
  • Riverpod state management for reactive UI updates
  • Lottie animations for smooth loading states
  • Responsive design that works across different screen sizes

Backend: Supabase with Edge Functions

Instead of building a custom backend, I leveraged Supabase for maximum efficiency:

Database Schema:

-- Core dreams table
CREATE TABLE dreams (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  title TEXT NOT NULL,
  content TEXT NOT NULL,
  dream_date DATE NOT NULL,
  mood_rating INTEGER, -- 3, 6, or 9 (sad, neutral, happy)
  is_lucid BOOLEAN DEFAULT FALSE,
  tags TEXT[],
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- AI analysis results
CREATE TABLE dream_analyses (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  dream_id UUID REFERENCES dreams(id) ON DELETE CASCADE,
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  analysis_text TEXT NOT NULL,
  insights JSONB NOT NULL, -- Themes, emotions, symbols, etc.
  model_used TEXT DEFAULT 'gpt-3.5-turbo',
  confidence_score DECIMAL(3,2) DEFAULT 0.85,
  credits_consumed INTEGER DEFAULT 1,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

AI Analysis: OpenAI Edge Functions

The real magic happens in the AI analysis system. I deployed a Supabase Edge Function that integrates with OpenAI:

Edge Function Deployment:

// supabase/functions/analyze-dream/index.ts
import { serve } from "https://deno.land/std@0.168.0/http/server.ts"
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

serve(async (req) => {
  const { dreamText, userId } = await req.json()

  // Check user credits and subscription
  const user = await supabase
    .from('user_profiles')
    .select('subscription_tier, credits_remaining')
    .eq('id', userId)
    .single()

  if (!user.data?.credits_remaining && user.data?.subscription_tier === 'free') {
    return new Response(JSON.stringify({
      error: 'Insufficient credits'
    }), { status: 402 })
  }

  // Analyze with OpenAI
  const analysis = await openai.chat.completions.create({
    model: "gpt-3.5-turbo",
    messages: [{
      role: "system",
      content: "You are a professional dream analyst. Provide insights about themes, emotions, symbols, and lucidity probability."
    }, {
      role: "user",
      content: dreamText
    }],
    max_tokens: 200 // Cost optimization
  })

  // Store results and update credits
  // ... implementation
})

Smart Features That Actually Work

1. Intelligent Dream Logging

The app goes beyond basic text entry:

class Dream {
  final String id;
  final String title;
  final String content;
  final DateTime dreamDate;
  final int? moodRating; // 3 (sad), 6 (neutral), 9 (happy)
  final bool isLucid;
  final List<String> tags;
  final bool hasAiAnalysis;
  final String? aiAnalysisText;

  // Auto-generates titles if user doesn't provide one
  String get displayTitle {
    if (title.trim().isNotEmpty) return title;
    return DreamTitleGenerator.generateTitle(content);
  }
}

2. AI-Powered Analysis System

Each dream can be analyzed for:

  • Themes: Recurring patterns (flying, water, people)
  • Emotions: Underlying emotional content
  • Symbols: Psychological meanings of dream elements
  • Lucidity Probability: Likelihood the dream was lucid
  • Mood Correlation: How the dream relates to daily mood
  • Recommendations: Personalized tips for lucid dreaming

3. Freemium Business Model

I implemented a complete freemium system:

class UserSubscription {
  final String subscriptionTier; // 'free', 'premium', 'ultra'
  final int creditsRemaining;
  final DateTime? premiumExpiresAt;

  bool get canAnalyzeDream => isPremium || creditsRemaining > 0;

  int get monthlyAnalysisLimit {
    switch (subscriptionTier) {
      case 'free': return 10;
      case 'premium': return 50;
      case 'ultra': return -1; // Unlimited
    }
  }
}

Business Logic:

  • Free Tier: 10 AI analyses per month
  • Premium: 50 analyses + advanced insights
  • Ultra: Unlimited + priority processing
  • Cost per analysis: ~$0.001 (highly profitable)

Technical Deep Dive

State Management with Riverpod

Coming from my network engineering background, I appreciate robust state management. Riverpod provides exactly that:

class DreamNotifier extends StateNotifier<AsyncValue<List<Dream>>> {
  final SupabaseService _supabaseService;

  DreamNotifier(this._supabaseService) : super(const AsyncValue.loading()) {
    loadDreams();
  }

  Future<void> loadDreams() async {
    try {
      state = const AsyncValue.loading();
      final dreams = await _supabaseService.getDreams();
      state = AsyncValue.data(dreams);
    } catch (error, stackTrace) {
      state = AsyncValue.error(error, stackTrace);
    }
  }

  Future<void> addDream(Dream dream) async {
    // Optimistic updates for better UX
    state.whenData((dreams) {
      state = AsyncValue.data([dream, ...dreams]);
    });

    try {
      await _supabaseService.insertDream(dream);
      loadDreams(); // Refresh from server
    } catch (error) {
      // Rollback on error
      loadDreams();
      rethrow;
    }
  }
}

Modern UI with Custom Theming

The app features a carefully crafted design system:

class AppTheme {
  static const dreamPurple = Color(0xFF6B46C1);
  static const dreamCyan = Color(0xFF06B6D4);
  static const dreamNight = Color(0xFF0F172A);

  static ThemeData get lightTheme => ThemeData(
    useMaterial3: true,
    colorScheme: ColorScheme.fromSeed(
      seedColor: dreamPurple,
      brightness: Brightness.light,
    ),
    cardTheme: CardTheme(
      elevation: 2,
      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
    ),
  );
}

Performance Optimizations

Learning from my telecom experience with large-scale systems:

  1. Lazy Loading: Dreams load on-demand with pagination
  2. Image Optimization: Lottie animations instead of heavy GIFs
  3. State Persistence: User preferences saved locally
  4. Offline Support: Core functionality works without internet
  5. Memory Management: Proper disposal of resources and listeners

The AI Analysis in Action

Here’s what makes the AI system special:

Prompt Engineering

I spent considerable time optimizing the AI prompts for cost and accuracy:

You are a professional dream analyst. Analyze this dream in exactly 2-3 sentences.

Then provide:
- Themes: [list of 2-4 main themes]
- Emotions: [2-3 primary emotions detected]
- Symbols: [2-3 key symbols with brief meanings]
- Lucidity Probability: [0.0-1.0 score]
- Mood Correlation: [positive/neutral/negative]
- Recommendations: [1-2 actionable lucid dreaming tips]

Be concise but insightful. Focus on psychological accuracy.

Dream: [USER_DREAM_TEXT]

Cost Optimization

  • Token Limit: 200 tokens max per analysis (~$0.001)
  • Model Selection: GPT-3.5-turbo for cost efficiency
  • Batch Processing: Multiple dreams analyzed together for premium users
  • Smart Caching: Similar dreams get cached responses

Real-World Usage & Impact

Since deploying the beta:

User Engagement

  • Average Session: 3.2 minutes (perfect for dream logging)
  • Return Rate: 67% weekly retention (better than most journaling apps)
  • Analysis Usage: 78% of users analyze at least one dream

Business Metrics

  • Conversion Rate: 12% free → premium conversion
  • Monthly Revenue Potential: $500-2000 at scale
  • Unit Economics: 85% profit margin on AI analyses

User Feedback

“Finally, an app that actually helps me understand my dreams instead of just storing them.”

“The AI analysis is surprisingly accurate. It picked up on themes I didn’t even notice.”

Technical Challenges Solved

1. Real-Time Data Sync

// Supabase real-time subscriptions
final subscription = supabase
  .from('dreams')
  .stream(primaryKey: ['id'])
  .eq('user_id', userId)
  .listen((data) {
    // Update UI in real-time when data changes
    ref.read(dreamProvider.notifier).updateFromStream(data);
  });

2. Offline-First Architecture

class OfflineDreamStorage {
  Future<void> saveOfflineDream(Dream dream) async {
    final prefs = await SharedPreferences.getInstance();
    final offlineDreams = getOfflineDreams();
    offlineDreams.add(dream);
    await prefs.setString('offline_dreams', jsonEncode(offlineDreams));
  }

  Future<void> syncOfflineDreams() async {
    final offlineDreams = await getOfflineDreams();
    for (final dream in offlineDreams) {
      await supabaseService.insertDream(dream);
    }
    await clearOfflineDreams();
  }
}

3. Complex JSON Handling

class DreamAnalysis {
  final DreamInsights insights;

  factory DreamAnalysis.fromJson(Map<String, dynamic> json) {
    return DreamAnalysis(
      insights: DreamInsights.fromJson(json['insights']),
      // ... other fields
    );
  }

  // No code generation needed - clean manual serialization
}

What I Learned Building This

1. Mobile Development Maturity

Flutter has come a long way. The developer experience with hot reload, the widget system, and package ecosystem made complex features surprisingly manageable.

2. AI Integration Reality

The hype around AI is real, but the implementation details matter. Cost optimization, prompt engineering, and error handling are crucial for production apps.

3. Freemium Business Models

Users are willing to pay for AI-powered insights, but the free tier needs to provide genuine value. The conversion funnel is all about demonstrating value before asking for payment.

4. State Management Evolution

Riverpod feels like the future of Flutter state management. It’s more complex than Provider but scales beautifully for real applications.

Development Stats

  • Development Time: 3 months (part-time while studying)
  • Lines of Code: ~5,000 Dart + 500 TypeScript (Edge Functions)
  • Dependencies: 15 packages (kept lean)
  • Test Coverage: 67% (ongoing improvement)
  • Platforms: Android, iOS, Web ready

Future Roadmap

Phase 1: Enhanced AI Features

  • Dream Prediction: ML models predicting likely dream themes
  • Personalization: AI that learns individual dream patterns
  • Sleep Integration: Correlation with sleep tracking data

Phase 2: Social Features

  • Anonymous Sharing: Community insights without privacy loss
  • Dream Challenges: Gamified lucid dreaming goals
  • Expert Analysis: Connect with certified dream therapists

Phase 3: Advanced Analytics

  • Pattern Recognition: Long-term trend analysis
  • Mood Correlation: Integration with mental health tracking
  • Custom Insights: Personalized dashboard with actionable recommendations

The Tech Stack That Works

Frontend:

  • Flutter 3.8+ with Material Design 3
  • Riverpod for state management
  • Lottie for animations
  • SharedPreferences for local storage

Backend:

  • Supabase (PostgreSQL + Auth + Edge Functions)
  • OpenAI GPT-3.5-turbo for analysis
  • Row Level Security for data privacy

DevOps:

  • GitHub Actions for CI/CD
  • Automated testing and deployment
  • Environment-based configuration

Why This Project Matters

Somnia isn’t just a portfolio piece - it’s a working product that solves real problems. It demonstrates:

  1. Full-Stack Mobile Development: End-to-end Flutter application with backend integration
  2. AI/ML Integration: Practical application of LLMs with cost optimization
  3. Business Model Implementation: Complete freemium system with subscription management
  4. Modern Architecture: Clean code practices and scalable patterns
  5. User-Centered Design: Solving actual user problems with thoughtful UX

As an engineering student preparing for my internship in 2026, this project showcases my ability to take complex technical concepts and turn them into polished, user-facing applications that people actually want to use.

The intersection of AI, mobile development, and human psychology fascinates me - and Somnia proves that with the right technical approach, you can build products that genuinely enhance people’s understanding of themselves.

Somnia is currently in beta testing. The full source code demonstrates advanced Flutter patterns, AI integration, and production-ready architecture. Contact me if you’d like to discuss the technical implementation or explore collaboration opportunities.