The Dashboard

The Dashboard is a calm, reflective Life OS for people who want help understanding their days before those days run away from them.

It is built for users who do not want another streak app, another guilt machine, or another productivity tool that mistakes pressure for progress.

Instead, The Dashboard helps people:

• understand what kind of day they are actually in
• notice drift before it becomes a spiral
• choose one meaningful move instead of ten scattered ones
• reconnect planning, recovery, honesty, faith, and follow-through
• return without shame when life gets heavy

This repository is open source and designed to be useful for both:

• people exploring The Dashboard as a product
• builders who want to fork it into their own coaching, wellness, planning, or reflective operating system

What The Dashboard Is

The Dashboard is a React + TypeScript + Supabase app that turns real-life signals into calm daily guidance.

Those signals can include:

• calendar load and meeting density
• wearable recovery, sleep, and strain
• quick check-ins about mood, stress, and energy
• daily moves and kept promises
• planner activity and environment resets

The product interprets those signals into a daily state read such as:

• what matters most today
• what needs protection
• whether this is a stretch day, recovery day, or protection day
• what your main quest is
• what one support move would help most

The Core Philosophy

The Dashboard is built around a simple idea:

You cannot control everything, but you can learn to respond well to what is actually yours.

The current product language centers on:

• Life perspective: onboarding uses age and season-of-life framing to make the app feel personal from the start
• Starter team: the 5 Controllables are presented as a team you can lean on
• Moves: daily actions are framed as meaningful moves, not chores
• Charge: the product uses grounded energy language instead of pressure-heavy productivity language
• Evolution: progress supports repair, return, and recovery, not only perfect consistency
• Regions / chapter quests: progression is meaningful without becoming childish or fantasy-heavy
• Drift and alignment: the app tracks how close lived life is to what matters most right now

The 5 Controllables

The Dashboard treats the 5 Controllables like a starter team:

• Awareness = scout Helps the user check in with God, tell the truth, surrender what they cannot control, and notice what is happening internally before reaction takes over.
• Perspective = translator Helps the user zoom out, reframe wisely, and remember that one hard moment is not the whole story.
• Habit = builder Helps the user turn intention into one concrete rep.
• Wellness = charger Helps the user pay attention to recovery, sleep, stress, movement, and energy.
• Environment = protector Helps the user reduce friction and shape the world around them so the next right move is easier.

Who This Can Help

The Dashboard is especially useful for people who:

• feel scattered by the amount of life they are carrying
• want a daily operating system that feels emotionally intelligent
• need help re-entering after drift, burnout, or inconsistency
• want faith, reflection, planning, and recovery to live in one place
• are tired of all-or-nothing self-improvement tools

It can also be forked into products for:

• coaching
• founder life management
• wellness / readiness
• Christian reflection and spiritual grounding
• reflective planning
• behavior change without shame-heavy gamification

What Using The Dashboard Feels Like

If the product is working well, the user should feel:

• calmer, because the app narrows the day down instead of exploding it
• more honest, because it makes room for reality instead of performance
• more supported, because return and repair count
• more grounded, because the app reacts to signals instead of pretending every day is the same

This is not a dopamine trap. It is meant to feel premium, useful, and steady.

A Typical Daily Flow

For a user, the app usually works like this:

1. Open the home dashboard.
2. See the daily read: what kind of day it is, what matters most, what needs protecting.
3. Choose one main quest.
4. Complete one or more daily moves with the starter team.
5. Use planner, wellness, money, or vault surfaces as needed.
6. Return later for re-alignment rather than perfection.

Main Product Surfaces

The app already contains a broad set of “life portal” surfaces. Depending on your fork and environment, these can include:

• Home dashboard Daily game-state read, main quest, support move, drift/alignment, and return-from-drift support.
• Onboarding Life perspective, season-of-life framing, starter team reveal, and chapter recommendation.
• Planner Time blocks, tasks, routines, and calendar-aware planning.
• Vault Notes, reflections, captured context, and longer-term memory.
• Wellness Recovery, sleep, health sync, and body-aware guidance.
• Money Bills, subscriptions, budgets, goals, and weekly financial resets.
• Operator / AI guidance Structured guidance and assistant behavior built around the Controllables.
• Regions / chapter quests Lightweight progression and weekly focus loops.

If You Are New Here

Use this checklist to get oriented quickly.

As a user or product reviewer

Start with:

• the onboarding flow
• the home dashboard
• daily moves
• planner
• one recovery or return-to-drift path

That gives the clearest feel for the product.

As a developer or builder

Start with:

• src/pages/Home.tsx
• src/components/dashboard
• src/components/onboarding
• src/hooks
• src/lib
• supabase/functions
• supabase/migrations

Those folders explain most of the product quickly.

Quick Start For Local Development

1. Fork and clone

git clone https://github.com/YOUR_USERNAME/thecontrollables.git
cd thecontrollables

2. Install dependencies

npm is the safest default for this repo:

npm install

3. Add frontend environment variables

Create .env.local or .env:

VITE_SUPABASE_URL=your_supabase_project_url
VITE_SUPABASE_PUBLISHABLE_KEY=your_supabase_publishable_or_anon_key
VITE_SUPABASE_PROJECT_ID=your_supabase_project_id

# Optional telemetry
VITE_POSTHOG_KEY=
VITE_POSTHOG_HOST=
VITE_SENTRY_DSN=
VITE_SENTRY_TRACES_SAMPLE_RATE=
VITE_ENABLE_SUPABASE_ANALYTICS=false

Minimum required for the frontend to boot:

• VITE_SUPABASE_URL
• VITE_SUPABASE_PUBLISHABLE_KEY

4. Run the app

npm run dev

5. Build for sanity check

npm run build

Running Supabase

You can point the frontend at a hosted Supabase project, or run Supabase locally.

Local workflow

If you have the Supabase CLI installed:

supabase start
supabase db reset
supabase functions serve

This is the best option if you want to work on schema or edge functions.

Server-Side Secrets

Several app capabilities depend on Supabase Edge Functions and server-side secrets.

These are configured in Supabase, not in the Vite .env file.

Common secrets used in this repo:

• SUPABASE_URL
• SUPABASE_ANON_KEY
• SUPABASE_SERVICE_ROLE_KEY
• LOVABLE_API_KEY
• RESEND_API_KEY
• GOOGLE_CLIENT_ID
• GOOGLE_CLIENT_SECRET
• WHOOP_CLIENT_ID
• WHOOP_CLIENT_SECRET
• STRIPE_SECRET_KEY
• STRIPE_PRICE_ID_PLUS
• STRIPE_PRICE_ID_PRO

You do not need every integration configured to run the app locally.

Useful defaults

• no wearable secrets: the app still works, but without wearable sync
• no Google secrets: planner and integration OAuth flows are limited
• no LOVABLE_API_KEY: AI-powered functions degrade or stop working
• no RESEND_API_KEY: email flows will not send
• no Stripe secrets: billing flows will not work

How The Dashboard Can Help A Real User

The easiest way to explain the product is:

The Dashboard helps a person stop asking, “How do I get everything together?” and start asking, “What kind of day is this, what matters most, and what is one honest move I can make from here?”

Practically, that means the app can help a user:

• notice overload before the day collapses
• protect recovery on hard days
• choose a smaller, keepable promise
• see drift early and re-align without shame
• use planning and reflection together instead of separately
• bring spiritual grounding into daily self-leadership

How To Explore The Product In The Right Order

If you want to understand the experience the way a user would, follow this order:

1. Onboarding Learn the life perspective, current season, and starter team framing.
2. Home See how the product reads the day and narrows it down.
3. Daily moves Understand the Controllables as lived behavior.
4. Return from drift This is one of the most important trust-building loops in the product.
5. Planner See how the app moves from reflection into execution.
6. Wellness / Money / Vault These expand the app into a fuller life portal.

How To Fork And Make It Your Own

You do not need a backend rewrite to customize The Dashboard.

Most forks should begin with:

• product language
• interpretation rules
• onboarding framing
• AI voice
• which modules are emphasized

Best low-risk customization points

1. Product language and framing

Good files to start with:

• src/pages/Home.tsx
• src/pages/QuickStart.tsx
• src/components/dashboard
• src/components/onboarding
• src/lib/awarenessLanguage.ts
• src/lib/controllableRoster.ts

2. Daily signal interpretation

If you want the app to react differently to stress, recovery, energy, or calendar load:

• src/lib/signalInterpreter.ts
• src/hooks/useGameSignals.ts
• src/lib/driftAlignment.ts
• src/hooks/useDriftAlignment.ts

This is one of the best places to customize the product without destabilizing the data model.

3. Onboarding and life-season framing

If you want different identity, age, season, or worldview framing:

• src/lib/lifePerspective.ts
• src/components/onboarding
• src/pages/QuickStart.tsx

4. Team / move system

If you want different team roles, move semantics, or progression tone:

• src/hooks/useDailyRings.ts
• src/components/dashboard/DailyRings.tsx
• src/components/dashboard/RingActionCard.tsx
• src/components/dashboard/ControllableHub.tsx
• src/components/dashboard/ControllableLevelsCard.tsx

5. AI behavior

If you want to adjust the assistant’s voice or product theology/philosophy:

• supabase/functions/ai-chat/index.ts
• supabase/functions/ai-chat/controllables-knowledge.ts
• supabase/functions/ai-reflect/index.ts
• supabase/functions/daily-os-plan/index.ts
• supabase/functions/operator-console/index.ts

Fork strategies that fit this repo well

This codebase is a good fit if you want to build:

• a founder dashboard
• a Christian daily alignment app
• a reflective coaching portal
• a wellness-aware planner
• a calmer habit and recovery app
• a family or household dashboard
• a life admin operating system

Repository Map

If you are scanning the codebase for the first time:

• src/pages Top-level routes such as home, planner, wellness, money, onboarding, and auth.
• src/components/dashboard Most of the product personality lives here.
• src/components/onboarding Entry experience and framing logic.
• src/hooks Data access, interpretation hooks, and UI orchestration hooks.
• src/lib Shared product rules, adapters, language helpers, and derived logic.
• supabase/migrations Database schema history.
• supabase/functions AI, integrations, sync, email, push, and server-side orchestration.

Design Guardrails For Contributors

This repo works best when contributors keep a few product rules intact:

• do not make the app feel childish
• do not turn it into a dopamine trap
• do not add more cards if an existing one can be repurposed
• prefer adapter layers over backend rewrites
• keep the tone calm, emotionally useful, and premium
• let repair and re-entry count just as much as forward momentum

Contributing

Issues and pull requests are welcome.

If you open a PR, it helps to say whether you are changing:

• product language
• onboarding
• dashboard behavior
• AI behavior
• signal interpretation
• Supabase schema
• integrations

That makes review easier because this app blends UX, product semantics, and backend behavior tightly.

Licensing

If you want others to reuse this repo clearly, add a root LICENSE file.

A public repository without a license is visible, but reuse rights are not automatically clear.