Lora's Command Center

What you’re building

Twenty lessons. You have built IP research tools, market analyzers, financial planners, game mechanic specifications, playable prototypes, sound systems, level editors, test harnesses, and a full demo. Each one lives in its own folder. Each one answered a specific question. None of them talk to each other.

This lesson fixes that.

You are building a unified dashboard — Lora’s Command Center — that connects everything you have built into two views and one decision. The Money View tracks your personal financial life: savings rate, investment portfolio, and a projection that tells you exactly when you could afford to quit your job and start the studio. The Studio View tracks the game company: IP pipeline status, budget scenarios, prototype progress, market comparisons, and a crowdfunding readiness score. Between them, a bridge calculation answers the question that actually matters: “Based on my savings rate and the studio’s estimated burn rate, when can I realistically start?”

This is the capstone. Not because it is the most technically complex thing you have built — the playable demo was harder. This is the capstone because it is the cockpit. Every decision you make about the game company starts here. Every financial milestone you hit shows up here. The dashboard does not build the game for you. It tells you whether you are ready to build it.

💬Two lives, one dashboard

You have a day job and a dream. The day job pays rent and fills investment accounts. The dream costs money and takes time. Most people keep these in separate mental buckets — “my finances” over here, “my game studio idea” over there — and never connect them. The Command Center forces the connection. Your savings rate is not just a personal finance metric. It is the clock counting down to the day you can afford to start. That reframe changes everything.

By the end of this lesson you will have a React application with localStorage persistence, two tabbed views (Money and Studio), a bridge calculation that connects personal finance to founder readiness, a crowdfunding kit section, and a go/no-go decision integrator that pulls every signal from the entire module into a single recommendation with a confidence score.

ℹSoftware pattern: Multi-domain dashboard with decision aggregation

Multiple data domains (personal finance, project management, market analysis) rendered in a unified interface with cross-domain calculations. This pattern appears in executive dashboards, operations centers, and any context where decisions require synthesizing signals from multiple independent systems. The key technique is defining a shared data model that bridges domains without coupling them.

The showcase

Here is what the finished Command Center gives you:

Money View tab:

Savings Rate Tracker: Monthly income, monthly expenses, savings rate percentage, trend over time (Chart.js sparkline). Pre-filled with editable defaults.
Investment Portfolio Summary: Account balances by type (401k, Roth IRA, brokerage), total portfolio value, asset allocation pie chart, estimated annual return.
Founder Runway Projection: “At your current savings rate of X% and estimated studio burn rate of $Y/month, you can self-fund for Z months starting [date].” Editable target date. Shows how much you need saved by that date.

Studio View tab:

IP Pipeline Status: Where you stand on rights acquisition (from L1-L4 data patterns). Status indicators: research complete, contact initiated, terms proposed, deal signed.
Budget Scenarios: Summary cards from L8 runway planner data — self-funded, Kickstarter, publisher. Monthly burn, runway months, funding gap.
Prototype Progress Checklist: Every prototype from L10-L19 with completion status. Percentage complete bar.
Market Comp Summary: Key metrics from L5-L7 — comparable titles, revenue estimates, market positioning.
Crowdfunding Readiness Score: Calculated from checklist completion (demo built? trailer beat sheet done? landing page copy ready? press kit assembled?).

Bridge section (visible on both tabs):

“Based on your savings rate and estimated studio burn rate, here’s when you could realistically start”
Timeline visualization showing savings growth, target start date, and runway from that point
Adjustable parameters: savings rate, target start date, studio burn rate, initial funding source

Go/No-Go Decision Integrator:

Pulls all signals: IP availability, market viability, financial readiness, prototype completeness, crowdfunding readiness
Each signal scored 0-100 with a weight
Weighted composite score with confidence level
Final recommendation: GO, CONDITIONAL GO, or NOT YET with specific blockers listed

The prompt

Open your terminal, navigate to a project folder, start your AI CLI tool, and paste this prompt:

Build a React application (using Vite) called command-center that serves as
a unified personal + studio dashboard. This is "Lora's Command Center" -- the
cockpit for managing personal finances and a game studio startup simultaneously.

PROJECT STRUCTURE:
command-center/
  package.json
  index.html
  src/
    App.jsx                    (tab navigation, localStorage persistence, state)
    components/
      TabBar.jsx               (Money View / Studio View toggle)
      money/
        SavingsTracker.jsx     (monthly income, expenses, savings rate, trend)
        PortfolioSummary.jsx   (investment accounts, allocation, returns)
        FounderRunway.jsx      (personal savings to studio funding projection)
      studio/
        IPPipeline.jsx         (IP rights acquisition status tracker)
        BudgetScenarios.jsx    (three funding scenario summary cards)
        PrototypeChecklist.jsx (L10-L19 prototype completion tracker)
        MarketComps.jsx        (comparable titles and revenue summary)
        CrowdfundingKit.jsx    (readiness score, landing copy, trailer beats)
      bridge/
        BridgeCalculation.jsx  (connects savings to founder start date)
        Timeline.jsx           (visual timeline: savings growth to studio launch)
      decision/
        GoNoGo.jsx             (weighted signal aggregation and recommendation)
        SignalCard.jsx         (individual signal score display)
    data/
      defaults.js             (pre-filled data for all sections)
    styles/
      dashboard.css           (dark theme, card layout, responsive grid)

REQUIREMENTS:

1. DEFAULT DATA (src/data/defaults.js)
   Pre-fill with realistic personal finance and studio data:

   PERSONAL FINANCE:
   - Monthly gross income: $6,500
   - Monthly expenses breakdown:
     Rent: $1,400
     Utilities: $180
     Car payment: $350
     Insurance (auto + renters): $200
     Groceries: $450
     Subscriptions (streaming, gym, etc.): $120
     Phone: $85
     Gas/transportation: $150
     Dining out: $200
     Personal/misc: $300
   - Total monthly expenses: $3,435
   - Monthly savings: $3,065
   - Savings rate: 47.2%
   - Current savings account balance: $28,000
   - Monthly savings trend (last 6 months): [2800, 2950, 3100, 2900, 3200, 3065]

   INVESTMENT PORTFOLIO:
   - 401k balance: $45,000 (employer match 4%, contributing 10%)
   - Roth IRA balance: $12,500 (maxing at $7,000/year)
   - Brokerage account: $8,200 (index funds)
   - Total portfolio: $65,700
   - Asset allocation: US stocks 70%, international stocks 15%, bonds 10%, cash 5%
   - Estimated annual return: 8% (historical average)
   - Monthly portfolio contribution: $1,225 (401k: $650 + match $260, Roth: $583)

   STUDIO DATA:
   - Estimated monthly burn rate: $68,000 (from L8 runway planner)
   - IP pipeline stage: "Research Complete" (from L1-L4)
   - Budget scenarios (from L8):
     Self-funded: $250K starting, 3.7 months runway
     Kickstarter ($800K goal): ~12 months runway
     Publisher ($2M deal): 24+ months runway
   - Prototype status (L10-L19):
     L10 Combat Loop: complete
     L11 Movement/Camera: complete
     L12 Enemy Behaviors: complete
     L13 Sound/VFX: complete
     L14 Asset Style Guide: complete
     L15 HUD/Inventory: complete
     L16 Dialogue/Objectives: complete
     L17 Level Editor: complete
     L18 Test Harness: complete
     L19 Playable Demo: complete
   - Market comps (from L5-L7):
     System Shock Remake: $30M gross estimated, 2.5 years dev
     Destroy All Humans Remake: $50M gross estimated, 2 years dev
     Shadow Man Remastered: $5M gross estimated, 1 year dev
     Average comp gross: $28.3M

   CROWDFUNDING CHECKLIST:
   - Playable demo: done (L19)
   - Trailer beat sheet: not started
   - Landing page copy: not started
   - Press kit: not started
   - Reward tiers designed: not started
   - Community Discord/social: not started
   - Email list: not started

2. APP STATE AND PERSISTENCE (src/App.jsx)
   - All data stored in React state, initialized from defaults
   - On every state change, persist to localStorage with key "lora-command-center"
   - On load, read from localStorage if available, otherwise use defaults
   - "Reset to Defaults" button in footer
   - Tab state persisted (remembers which tab was open)

3. TAB BAR (src/components/TabBar.jsx)
   - Two tabs: "Money View" (dollar icon) and "Studio View" (gamepad icon)
   - Active tab has accent underline (#a855f7 purple)
   - Smooth content transition on tab switch
   - Bridge Calculation section visible on BOTH tabs (sticky at bottom or
     always-visible panel)

4. SAVINGS TRACKER (src/components/money/SavingsTracker.jsx)
   - Editable income field (monthly gross)
   - Editable expense table with categories, amounts, and notes
   - Auto-calculated: total expenses, monthly savings, savings rate percentage
   - Savings rate displayed large: "47.2%" with color coding
     (green > 40%, amber 20-40%, red < 20%)
   - Sparkline chart (Chart.js line, 100px wide) showing 6-month savings trend
   - "Add Expense" and "Remove" buttons for custom line items

5. PORTFOLIO SUMMARY (src/components/money/PortfolioSummary.jsx)
   - Editable account cards: name, balance, monthly contribution, type
   - Doughnut chart (Chart.js) showing asset allocation by percentage
   - Total portfolio value displayed prominently
   - Estimated annual return input (default 8%)
   - Projection: "At current contribution rate, portfolio reaches $X in Y years"
   - Table: account name, balance, monthly contribution, YTD return

6. FOUNDER RUNWAY (src/components/money/FounderRunway.jsx)
   - Inputs: current savings balance, monthly savings rate, target start date,
     studio monthly burn rate
   - Calculation: savings at target date = current + (monthly savings * months until target)
   - Self-fund runway = savings at target date / studio burn rate
   - Output: "At your savings rate of $3,065/mo, by [target date] you will have
     $X saved. At a studio burn rate of $68K/mo, that self-funds X.X months."
   - Warning thresholds: green (6+ months self-fund), amber (3-6), red (< 3)
   - "What if" slider: adjust savings rate and see runway change in real time

7. IP PIPELINE (src/components/studio/IPPipeline.jsx)
   - Pipeline stages: Research, Outreach, Negotiation, Term Sheet, Signed
   - Visual progress bar with current stage highlighted
   - Editable status notes for each stage
   - "Last updated" timestamp
   - Links/references to L1-L4 outputs (displayed as text, not functional links)

8. BUDGET SCENARIOS (src/components/studio/BudgetScenarios.jsx)
   - Three cards side by side (stacked on mobile):
     Self-Funded: starting capital, monthly burn, runway months, status indicator
     Kickstarter: goal, net after fees, personal capital added, runway months
     Publisher: advance total, milestone schedule, revenue share %, runway months
   - Each card: editable key numbers, auto-calculated runway
   - Visual runway bars (green/amber/red based on months vs 24-month target)
   - "Best option" highlight on the card with longest runway

9. PROTOTYPE CHECKLIST (src/components/studio/PrototypeChecklist.jsx)
   - List of L10-L19 with checkbox for each
   - Pre-filled as all complete (since Lora has done all the lessons)
   - Percentage complete bar at top: "10/10 prototypes complete (100%)"
   - Each item shows: lesson number, name, status, optional notes field
   - Ability to add custom prototype items beyond the curriculum

10. MARKET COMPS (src/components/studio/MarketComps.jsx)
    - Table: title, estimated gross revenue, dev time, platform, genre match score
    - Pre-filled with 3 comparables from L5-L7
    - "Add Comparable" button to add custom entries
    - Summary stats: average gross, average dev time, market size estimate
    - Bar chart comparing gross revenue across comparables

11. CROWDFUNDING KIT (src/components/studio/CrowdfundingKit.jsx)
    - Readiness checklist with completion percentage:
      Playable demo, Trailer beat sheet, Landing page copy, Press kit,
      Reward tiers, Community channels, Email list
    - Readiness score: 0-100 based on checklist completion
    - Score color: green (80+), amber (50-79), red (< 50)
    - LANDING PAGE COPY TEMPLATE (expandable section):
      Pre-written template with placeholders:
      "BloodRayne deserves a comeback. [STUDIO NAME] is building a faithful
      remake of the cult classic action game -- updated visuals, refined combat,
      the same vampire-slaying energy. We need your support to make it happen."
      Editable text area with formatting hints.
    - FEATURE MATRIX (expandable section):
      Two-column comparison: Original vs Remake features
      Pre-filled: "2002 graphics -> Modern 3D (Unreal/Unity)",
      "Fixed camera -> Dynamic camera", "Linear levels -> Semi-open levels",
      "Basic combo -> Expanded combo system with finishers"
    - TRAILER BEAT SHEET (expandable section):
      Template with timestamps:
      0:00-0:05 Black screen, logo
      0:05-0:15 Establishing shot, atmosphere
      0:15-0:30 Combat montage (blade combos, blood rage)
      0:30-0:40 Movement showcase (wall climb, rail grind)
      0:40-0:50 Boss tease
      0:50-0:60 Title card, release window, call to action
      Editable text area.

12. BRIDGE CALCULATION (src/components/bridge/BridgeCalculation.jsx)
    - Always visible at the bottom of whichever tab is active
    - Pulls: personal savings rate, current savings, studio burn rate, funding scenario
    - Core calculation:
      months_to_target = (target_savings - current_savings) / monthly_savings
      self_fund_months = target_savings / studio_burn_rate
      start_date = today + months_to_target
    - Display: "Based on your savings rate of $3,065/month and a studio burn
      rate of $68K/month, you could self-fund for X months starting [date].
      With Kickstarter funding, that extends to Y months. With a publisher,
      you are fully funded."
    - Editable: savings rate, target savings amount, burn rate, start date
    - Visual timeline bar showing: now -> savings milestone -> studio start ->
      runway end (with color coding per scenario)

13. TIMELINE (src/components/bridge/Timeline.jsx)
    - Horizontal timeline visualization (Chart.js or custom SVG)
    - Milestones: Today, Savings Goal Hit, Studio Launch, Runway End (per scenario)
    - Three overlaid lines for three funding scenarios
    - Hover to see exact dates and dollar amounts at each milestone
    - Responsive: collapses to vertical on mobile

14. GO/NO-GO DECISION (src/components/decision/GoNoGo.jsx)
    - Five signal cards in a row (stacked on mobile):

      a. IP Availability (weight: 25%)
         Score 0-100 based on pipeline stage:
         Research = 20, Outreach = 40, Negotiation = 60, Term Sheet = 80, Signed = 100

      b. Market Viability (weight: 20%)
         Score 0-100 based on: comp count (more = higher), average comp gross
         (higher = higher), market trend direction

      c. Financial Readiness (weight: 25%)
         Score 0-100 based on: savings rate (higher = higher), months of
         self-funding possible, best scenario runway vs 24-month target

      d. Prototype Completeness (weight: 15%)
         Score 0-100: (completed prototypes / total prototypes) * 100

      e. Crowdfunding Readiness (weight: 15%)
         Score 0-100: crowdfunding checklist completion percentage

    - COMPOSITE SCORE: weighted sum of all five signals
    - Confidence: based on how many signals have real data vs defaults
      "High confidence" (4-5 signals with real data),
      "Medium confidence" (2-3), "Low confidence" (0-1)
    - RECOMMENDATION:
      Score 80+: "GO -- Strong indicators across all dimensions. Start planning
      your launch timeline."
      Score 50-79: "CONDITIONAL GO -- Viable with caveats. Address these blockers:
      [list signals below 50]"
      Score < 50: "NOT YET -- Key blockers remain. Focus on: [list signals below 50]"
    - Visual: large circular gauge (0-100) with color fill
    - Blockers list: any signal below 50 is listed with its score and what
      would improve it

15. STYLING (src/styles/dashboard.css)
    - Dark theme: #09090b background, #111118 cards, #1e1e2a card borders
    - Accent: #a855f7 (purple) for active states and highlights
    - Text: #e0e0e0 primary, #9ca3af secondary
    - Card grid: 2-column on desktop, single column on mobile
    - Charts: dark theme config for Chart.js (dark grid, light labels)
    - Responsive breakpoint: 768px
    - Print-friendly media query (white background, dark text)

DEPENDENCIES: react, react-dom, chart.js, react-chartjs-2 (all via Vite)

SAMPLE INTERACTION:
User opens the app. Money View loads with pre-filled personal finance data.
Savings rate shows 47.2% in green. Portfolio shows $65,700 total.
Founder Runway shows: "At $3,065/month savings, by January 2028 you'll have
$83,170. At $68K/month burn, that self-funds 1.2 months."
User switches to Studio View. All 10 prototypes are checked. Crowdfunding
readiness is 14% (only demo is done). Market comps show $28.3M average gross.
Go/No-Go shows: CONDITIONAL GO at 62/100.
Blockers: "Crowdfunding Readiness (14/100) -- complete trailer, landing page,
and press kit. IP Availability (20/100) -- advance past research stage."
User checks off "Trailer beat sheet" in the crowdfunding kit. Readiness jumps
to 29%. Go/No-Go updates to 64/100. Still conditional, but moving.
User edits savings rate to $4,000/month (picked up freelance work). Bridge
calculation updates: self-fund runway extends from 1.2 to 1.6 months.
All changes persist to localStorage. Close the tab, reopen, everything is there.

💡This prompt is long because the dashboard is wide

The Command Center touches every tool you have built in this module. The prompt describes what each section shows and where the data comes from. You do not need the actual output files from previous lessons — the defaults.js file pre-fills everything with realistic data. But if you have real outputs from earlier tools (your actual market comps, your actual budget numbers), you can swap them in after generation. The dashboard is the frame. Your data is the picture.

What you get

After the LLM generates the application:

command-center/
  package.json
  index.html
  src/
    App.jsx
    components/
      TabBar.jsx
      money/
        SavingsTracker.jsx
        PortfolioSummary.jsx
        FounderRunway.jsx
      studio/
        IPPipeline.jsx
        BudgetScenarios.jsx
        PrototypeChecklist.jsx
        MarketComps.jsx
        CrowdfundingKit.jsx
      bridge/
        BridgeCalculation.jsx
        Timeline.jsx
      decision/
        GoNoGo.jsx
        SignalCard.jsx
    data/
      defaults.js
    styles/
      dashboard.css

Fire it up

cd command-center
npm install
npm run dev

Open the dev server URL. You should see the Money View tab active with your savings tracker, portfolio summary, and founder runway projection. The bridge calculation at the bottom shows the connection between your savings and the studio start date. Switch to Studio View to see IP pipeline, budget scenarios, prototype checklist, market comps, crowdfunding kit, and the go/no-go decision integrator.

If something is off

Problem	Follow-up prompt
localStorage not persisting	`Changes disappear on reload. Make sure App.jsx wraps every setState call with a useEffect that writes the full state to localStorage using JSON.stringify with the key "lora-command-center". On mount, read from localStorage with JSON.parse and use that as initial state if it exists.`
Charts not rendering on tab switch	`The Chart.js charts on the Studio View tab are blank until I resize the window. Chart.js canvases created in a hidden div don't size correctly. Use a key prop on the chart component that changes when the tab switches, forcing React to remount the chart. Or call chart.resize() in a useEffect that fires when the tab becomes active.`
Go/No-Go score not updating	`Changing values in the crowdfunding checklist doesn't update the Go/No-Go composite score. Make sure GoNoGo.jsx recalculates on every render by deriving the score from props/state, not from a cached value. Each signal score should be a function that reads current state and returns 0-100.`
Bridge calculation shows NaN	`The founder runway projection displays NaN months. Check that the monthly burn rate and savings values are parsed as numbers, not strings. Use parseFloat() on all input values before division. Also guard against division by zero if burn rate is 0.`
Tabs don’t switch	`Clicking Money View or Studio View does nothing. Make sure TabBar.jsx calls a setActiveTab function passed as a prop from App.jsx. The active tab state should live in App.jsx and conditionally render the MoneyView or StudioView component group based on the active tab string.`

Deep dive

Two domains, one decision

The Command Center does something unusual: it puts personal finance and business planning in the same interface. Most dashboard tools are single-domain. Mint tracks your money. Jira tracks your project. Pitch decks track your market. Nobody puts them together because they serve different audiences.

But you are not a corporation with departments. You are one person. Your savings rate directly determines when you can start the studio. Your studio burn rate directly determines how much you need saved. The prototype completion directly determines whether you have something to show investors. These are not separate concerns. They are the same concern viewed from different angles.

The bridge calculation makes this explicit. It takes a number from the Money View (savings rate) and a number from the Studio View (burn rate) and produces the answer to the question you actually care about: when can I start?

The go/no-go integrator is not a magic 8-ball

The composite score is a weighted average of five signals. It is not artificial intelligence. It is arithmetic. IP availability at 20% drags the score down. Crowdfunding readiness at 14% drags it down further. Prototype completeness at 100% pulls it up. The weights reflect judgment calls about what matters most — IP and financial readiness are weighted higher because they are hard blockers.

The value is not in the number. The value is in the blockers list. When the dashboard says “CONDITIONAL GO — address IP Availability (20/100) and Crowdfunding Readiness (14/100),” it is telling you exactly what to work on next. Not in vague terms. In specific, scored terms with a clear path to improvement.

🔍Why localStorage instead of a backend

The Command Center stores everything in the browser’s localStorage. No server, no database, no authentication. This is a deliberate choice for three reasons:

Privacy. This dashboard contains your real financial data — income, savings, investment balances. That data should not leave your machine unless you choose to share it. localStorage keeps it in your browser and nowhere else.

Simplicity. Adding a backend means a server, a database, deployment, and authentication. For a personal dashboard used by one person, that is overhead with no benefit. The data model fits comfortably in localStorage (typically 5-10MB limit, your data is under 100KB).

Portability. Export your state as a JSON file (add this customization if you want). Import it on another machine. Back it up to a USB drive. You own the data in a format you can read.

The tradeoff: if you clear your browser data, the dashboard resets. The “Reset to Defaults” button does this intentionally. If you want persistence beyond the browser, the customization section below covers adding a JSON export/import feature.

Customize it

Add JSON export and import

Back up your dashboard data:

Add an "Export Data" button in the footer that downloads the entire
localStorage state as a JSON file named "command-center-backup-YYYY-MM-DD.json".
Add an "Import Data" button that accepts a JSON file upload, validates it
has the expected structure, and loads it into state (replacing current data).
Show a confirmation dialog before import: "This will replace all current
data. Continue?"

Add a monthly review mode

Track your progress over time:

Add a "Monthly Snapshot" feature. A button in the footer labeled "Save
Monthly Snapshot" that saves the current state with a timestamp to a
localStorage array under key "lora-command-center-snapshots". Add a
"History" tab that shows a table of snapshots with date, savings rate,
portfolio value, Go/No-Go score, and crowdfunding readiness. Add a
Chart.js line chart showing these four metrics over time. This lets Lora
see month-over-month progress toward the studio launch.

Add a scenario comparison calculator

Model different life decisions:

Add a "What If" panel to the Money View that lets you model scenarios:
- "What if I move to a cheaper apartment?" (adjust rent, see savings rate change)
- "What if I pick up freelance work?" (add income line item)
- "What if I max out my 401k?" (adjust contribution, see portfolio projection)
- "What if I delay the studio start by 6 months?" (see additional savings accumulated)
Each scenario shows the delta: "This change extends your self-fund runway
by X months" or "This change adds $Y to your savings by [target date]."
Show scenarios side-by-side with the baseline.

Try it yourself

Open your CLI tool in an empty folder and paste the prompt.
Run npm install && npm run dev. Open the Money View. Look at your savings rate. Look at your portfolio. Look at the founder runway number. That number — the self-fund months — is the most important number on the entire dashboard.
Switch to the Studio View. All 10 prototypes should show complete. The crowdfunding readiness score should be low (14%) because you have a demo but no marketing materials. Look at the go/no-go score. It should say CONDITIONAL GO with clear blockers.
Edit your monthly income upward by $1,000 (maybe you picked up freelance consulting). Watch the savings rate recalculate. Watch the bridge calculation update. Watch the founder runway extend. Every dollar you save is a day closer to starting.
Check off “Trailer beat sheet” and “Landing page copy” in the crowdfunding kit. Watch the readiness score jump. Watch the go/no-go composite score tick upward. This is progress made visible.
Go to the bridge calculation. Adjust the target start date. See how much you need saved by then. See how many months of self-funding that buys. Now try different funding scenarios — does Kickstarter change the equation? Does a publisher deal make the start date irrelevant?
Close the browser tab. Reopen it. Everything should still be there. localStorage is doing its job.
Look at the go/no-go blockers list. That list is your to-do list. Not in the abstract. In specific, scored, prioritized terms.

Key takeaways

Personal finance and startup planning are the same problem. Your savings rate is your studio’s pre-funding runway. Separating them is a mental convenience that hides the real timeline.
The bridge calculation is the most important number. Not the portfolio value. Not the prototype count. The bridge: “At your savings rate and the studio’s burn rate, you can self-fund for X months starting [date].” That is the number that determines when you start.
The go/no-go integrator turns scattered signals into a decision. Five independent metrics combined into one score with explicit blockers. You stop wondering “am I ready?” and start looking at “what specifically is blocking me?”
Crowdfunding readiness is often the biggest gap. You built the prototype. You did the market research. You modeled the finances. But the trailer, landing page, press kit, and community channels take real work — and most aspiring founders underestimate them.
localStorage is enough for a personal dashboard. No server, no database, no auth. Your financial data stays on your machine. Export to JSON for backup. Import on another machine. You own it.

What’s next

💡You built the cockpit

Look at what you have. A market tracker that proves cult revivals are profitable. A financial model that shows what each funding path looks like. A mechanics specification that documents every system in the game. Ten working prototypes culminating in a playable demo. And now a dashboard that connects your personal financial life to your studio dream with a single number: when can you start?

That is not a lesson plan. That is a business plan with working software behind it.

The next step is yours. The Command Center will tell you when you are ready. The blockers list will tell you what to work on. The bridge calculation will tell you when the numbers line up. And when they do — when the go/no-go score hits 80 and the recommendation says GO — you will know it is not a gut feeling. It is data.

Rayne did not wait for permission. Neither should you. But she also did not charge in blind. She assessed the situation, picked her moment, and struck. The Command Center is your aura vision. Use it.

What you'll learn