Growth Engine

The autonomous company behind ReproClip

AI strategy → real human work → founder approval → distribution → verified revenue → a smarter next decision.

The idea

ReproClip can record a workflow and turn it into a focused product demo. Growth Engine answers the harder question: can the product learn how to grow itself without pretending that AI can replace judgment, customers, or payment truth?

This repository contains the project's major operating system. It gives ReproClip an AI CEO, an on-demand human workforce, approval gates around money, campaign and referral memory, real revenue attribution, and a founder console that refuses to manufacture success.

Pioneer decides what to try
        ↓
Terac recruits creators and tests work with real people
        ↓
The founder approves financial actions and creative releases
        ↓
ReproClip distributes attributed links and accepts support
        ↓
ReproClip records verified product revenue
        ↓
Growth Engine persists the evidence and Pioneer decides again

There are zero marketing employees, no seeded revenue, no invented engagement, and no automatic creator payout approval.

Sponsors became infrastructure

These tools are part of the project story, not a logo wall. The scope column is intentional: Linq and Stripe were used in the main ReproClip project, not as Growth Engine integrations.

Sponsor	Used in	How we used it	Evidence
Pioneer	Growth Engine	Runs the bounded AI CEO. It receives persisted business state and returns a schema-validated growth decision, budget, campaign hypothesis, and next actions using open-weight inference.	backend/app/services/pioneer.py
Terac	Growth Engine	Gives the AI company a real human supply layer. Growth Engine discovers Terac MCP tools, requests priced creator or research work, launches only after founder approval, and synchronizes verified submissions.	backend/app/services/terac.py
Render	Growth Engine	Hosts the FastAPI control plane and Next.js company console as a two-service Blueprint, runs database migrations before release, and keeps configuration in infrastructure-as-code.	render.yaml
Replay	Growth Engine	Captures reproducible browser-debugging evidence. Growth Engine stores the real Replay run URL and its explicit pass/fail checks so QA status is auditable instead of inferred.	POST /api/company/qa/replay
Linq	Main ReproClip project	Sends a finished ReproClip video link directly to the configured phone conversation through Linq's messaging API.	ReproClip Linq integration
Stripe	Main ReproClip project	Powers ReproClip's support Checkout and signature-verified payment webhook. Growth Engine only consumes the resulting product-side revenue signal.	ReproClip Stripe routes
Superserve	Main ReproClip project	Supplies isolated compute for ReproClip's media pipeline. Auto Edit creates a sandbox, analyzes interaction signals, runs FFmpeg, and returns the rendered artifact.	ReproClip Superserve integration
Lovable	Main ReproClip project	Accelerated early product and interface exploration for the customer-facing experience.	Product-design phase; production implementation lives in ReproClip

One loop, real state

Growth Engine does not let model output masquerade as company progress. Each stage advances only when the corresponding external event has been persisted.

1. Decide. Pioneer sees real metrics, Terac feedback, current spend, and prior decisions. Its JSON must pass a strict Pydantic schema and stay within the configured budget.
2. Commission. Terac receives a concrete creator or general-population research brief and returns a real feasibility request and price.
3. Approve. A founder token is required before spend launches and before creator work is accepted or rejected.
4. Distribute. Each campaign and creator gets an attributed /r/<code> link; visits are stored rather than estimated.
5. Verify. ReproClip writes verified payment events into the shared database; Growth Engine consumes them as product-side revenue signals.
6. Learn. Campaign economics and human preference results become the next Pioneer input snapshot.

What you can see

The Next.js operations console exposes the company as it really is:

• a live Pioneer CEO decision and its bounded rationale;
• campaigns tied to Terac jobs, creators, and human studies;
• individual creator submissions with explicit founder review;
• attributed visits, supporters, revenue, spend, CAC, ROAS, and contribution;
• a live activity stream backed by persisted events;
• a judge/demo view whose checkpoints remain visibly incomplete until real events exist.

Architecture

Layer	Technology	Responsibility
Company console	Next.js, React, Tailwind CSS	Decisions, campaigns, submissions, economics, demo state
Control plane	FastAPI, Pydantic, SQLAlchemy	Guarded workflows, schemas, integrations, event recording
Business memory	Supabase Postgres, Alembic	Campaigns, studies, creators, referrals, visits, payments, decisions
AI executive	Pioneer	Structured strategy from persisted state
Human workforce	Terac MCP	Creators, feedback panels, feasibility, verified results
Revenue input	ReproClip	Verified, attributed support-payment signals
Founder approval	Growth Engine	Token-gated spend and creative decisions
QA evidence	Replay	Reproducible browser runs and explicit checks
Media compute	Superserve via ReproClip	Isolated analysis and FFmpeg rendering
Deployment	Render Blueprint	FastAPI and Next.js services with pre-deploy migrations

Safety is a feature

• No fake traction. Human, social, and financial metrics remain zero or unavailable until real results are persisted.
• No model-controlled money. FOUNDER_APPROVAL_TOKEN gates spend and submission decisions.
• No unverified revenue. Only verified product-side payment events count.
• No imaginary integrations. Missing credentials keep an integration explicitly unavailable.
• No hidden chain of thought. Pioneer stores a concise business rationale, not private reasoning traces.
• No browser database secrets. Supabase credentials stay inside the FastAPI service.

Run it locally

cp .env.example .env

cd backend
python3 -m venv .venv
.venv/bin/pip install -r requirements.txt
.venv/bin/alembic upgrade head
.venv/bin/uvicorn app.main:app --reload

# In another terminal
cd web
npm install
npm run dev

Open http://localhost:3001/company. The API runs at http://localhost:8000. Without SUPABASE_DATABASE_URL, local development deliberately uses SQLite.

Production configuration

Create a Render Blueprint from render.yaml. Use Supabase's Session pooler URL on port 5432 for the API's SUPABASE_DATABASE_URL, then configure:

• SUPABASE_MIGRATION_URL
• APP_BASE_URL, PRODUCT_BASE_URL, and CORS_ORIGINS
• NEXT_PUBLIC_API_URL and COMPANY_API_URL
• PIONEER_API_KEY and PIONEER_MODEL
• TERAC_API_KEY, TERAC_MCP_URL, and a nonzero TERAC_BUDGET_USD
• optional Replay variables

Payment-provider secrets remain on ReproClip. Both services point to the same Supabase database so verified payment and attribution events become Growth Engine signals.

Verify the system

cd backend && .venv/bin/pytest -q
cd web && npm run typecheck && npm run lint && npm run build

The tests prove that zero-state metrics stay honest, a persisted product payment changes company revenue, Pioneer cannot return an unknown or unbounded decision, and creator work remains pending until explicit founder review.

Repository map

growth-engine/
├── backend/
│   ├── app/services/       # Pioneer, Terac, company metrics
│   ├── app/routers/        # company, campaigns, referrals
│   ├── alembic/            # production schema history
│   └── tests/              # honest company-loop tests
├── web/
│   ├── app/company/        # operating console
│   └── app/demo/           # real-state judge flow
├── render.yaml             # two-service deployment
└── .env.example            # configuration contract

Follow the experiment

This is an experiment in giving an open-source product a measurable, human-grounded growth loop—not replacing every person with a prompt.

If that is a future you want to explore, star Growth Engine, try ReproClip, and open an issue with the first part of the loop you would improve.

Built around real people, real payments, and real evidence.