NovaReelOS Master Spec

Vision

Build the world's first creator-owned operating system for short-form content. NovaReelOS is not another social app—it is the infrastructure layer that unifies creation, distribution, monetization, and analytics into a single composable platform. Where existing networks treat creators as content suppliers, NovaReelOS treats them as first-class stakeholders with transparent economics, portable data, and granular control over every aspect of their digital presence.

Mission

Eliminate the gap between creative output and economic return. Every view, like, share, and purchase flows through a transparent revenue pipeline where creators know exactly what they earn and why. No opaque algorithms suppressing reach. No hidden fees siphoning revenue. No platform lock-in trapping years of work behind a terms-of-service wall.

Creator-First Philosophy

Every architectural decision privileges the creator. The 45/55 revenue split is hardcoded into services/monetization.js—not stored in a config table, not adjustable by product managers, not negotiable in enterprise deals. Creator data is portable via GDPR-compliant export endpoints. Safety controls are granular down to individual post permissions. The Creator Bill of Rights is immutable and governs every feature shipped to production.

Creators own their audience graph, control who can download or repost their content, set per-surface pricing for brand deals, and receive real-time earnings breakdowns across all five monetization surfaces.

Creator Economy Pain Points

Today's dominant platforms extract maximum value from creators while returning minimum transparency. The result is a broken economic loop.

• Opaque Algorithms — Creators cannot see why their content is promoted or suppressed. Reach is unpredictable, making revenue forecasting impossible.
• Unpredictable Income — Revenue shares change without notice. Creator funds are withheld for weeks. Payout thresholds create artificial delays.
• No Data Portability — Audience relationships, content archives, and engagement history are locked inside each platform with no export path.
• Platform Lock-In — Years of content and community building become leverage for the platform, not the creator.
• Brand Deal Friction — Negotiating sponsorships is manual, undiscoverable, and lacks standardized pricing or attribution.

Brand Pain Points

• Fragmented Creator Landscape — Brands must search across multiple platforms, agencies, and marketplaces to find the right creators.
• Difficult Attribution — Connecting ad spend to creator-driven conversions requires stitching together incompatible analytics systems.
• No Unified Ad Auction — Each platform runs its own ad system with different rules, formats, and measurement standards.
• Manual Deal-Making — Brand-creator partnerships rely on email chains, spreadsheets, and handshake agreements with no structured workflow.

Market Opportunity

The creator economy is valued at $250B+ by 2027. Short-form video is the dominant content format across every demographic. Yet no platform gives creators both the tools to create and the economics to thrive. NovaReelOS fills that gap by treating monetization as a core system service, not an afterthought bolted onto a social feed.

Five Core Surfaces

NovaReelOS organizes all creator activity into five independent surfaces, each with its own content format, discovery logic, and monetization engine. Surfaces can be composed together (e.g., a LIVE session promoting a Shop product) but each operates as a standalone revenue channel.

OS Framing

NovaReelOS is layered like an operating system. Each layer has a clear responsibility boundary and communicates with adjacent layers through defined interfaces.

• Hardware Layer — Infrastructure: Render compute, Neon PostgreSQL, Polsia R2 object storage, CDN edge delivery.
• Kernel Layer — Data and auth: PostgreSQL schema, session management, magic link authentication, creator tokens, GDPR compliance.
• Services Layer — Monetization Engine, Ad Sales Engine, Brand Marketplace, Safety & Trust, Analytics, Push Notifications.
• Applications Layer — The five surfaces: Video Feed, Posts, Music, Shop, LIVE—each implemented as independent route groups.
• Shell Layer — Creator Dashboard, Brand Portal, Admin Pipeline, Onboarding Widget, Support Center.

Core Modules

Technology Stack

NovaReelOS is a server-rendered monolith built for speed and simplicity. No client-side framework, no build step, no hydration overhead. Pages render in milliseconds via EJS templates and ship as progressively-enhanced HTML with targeted JavaScript for interactive components.

System Layers

┌─────────────────────────────────────────────────┐
│  Shell Layer — Creator Dashboard, Brand Portal  │
├─────────────────────────────────────────────────┤
│  Application Layer — Feed, Shop, LIVE, Music    │
├─────────────────────────────────────────────────┤
│  Service Layer — Monetization, Ads, Safety      │
├─────────────────────────────────────────────────┤
│  Data Layer — PostgreSQL, R2 Storage, Events    │
├─────────────────────────────────────────────────┤
│  Infrastructure — Render, Neon, Polsia Proxy    │
└─────────────────────────────────────────────────┘

Event-Driven Revenue Pipeline

All monetization events flow through the revenue_events table, which serves as a unified event bus. Every creator action that generates revenue—an ad impression, a gift during LIVE, a shop sale, a brand deal completion—is recorded as an immutable event with pre-calculated creator and platform shares.

Creator Action ──► Event Dispatch ──► Revenue Split (45/55) ──► Creator Wallet
     │                    │                      │                      │
  [post/live/         [revenue_events       [services/            [dashboard/
   shop/music]         INSERT]               monetization.js]      monetization]

Directory Structure

// NovaReelOS codebase layout
server.js           // Entry point — middleware + route mounting
db/                 // Database layer
  index.js          // Shared PostgreSQL pool (single Pool instance)
  posts.js          // Content CRUD — create, feed, drafts, permissions
  creators.js       // Profile, follow graph, verification
  monetization.js   // Revenue event recording + queries
routes/             // Express route groups (one Router per file)
services/           // Business logic services
  monetization.js   // 45/55 split engine (source of truth)
views/              // EJS templates
public/             // Static assets (CSS, JS, images)
migrations/         // DDL migration scripts (.js only)

The 45/55 Model

The revenue split is the economic constitution of NovaReelOS. It is not a configuration value—it is a hardcoded constant in services/monetization.js, the single source of truth for all revenue calculations across the platform.

// services/monetization.js — immutable revenue split
const CREATOR_SHARE  = 0.45;  // 45% to creator
const PLATFORM_SHARE = 0.55;  // 55% to platform

function calculateRevenueSplit(grossAmount) {
  return {
    gross:    grossAmount,
    creator:  grossAmount * CREATOR_SHARE,
    platform: grossAmount * PLATFORM_SHARE
  };
}

Revenue Split Visualization

Surface Monetization Engines

Payout Logic

Revenue flows through a deterministic pipeline: gross revenue enters the system, the 45/55 split is applied, the creator share is allocated to their wallet, and the platform share covers infrastructure, moderation, and operating costs.

Gross Revenue ──► calculateRevenueSplit() ──► creator_amount (45%)
     $100.00          │                           $45.00
                      └──► platform_amount (55%)
                              $55.00

Revenue Events Table

Every monetization event is stored as an immutable row in revenue_events. This table is the audit trail for all money flowing through the platform.

-- revenue_events schema
CREATE TABLE revenue_events (
  id              SERIAL PRIMARY KEY,
  creator_id      INTEGER REFERENCES creator_profiles(id),
  surface         TEXT NOT NULL,       -- video|posts|music|shop|live
  event_type      TEXT NOT NULL,       -- ad_impression, gift, sale...
  gross_amount    NUMERIC(12,2),
  creator_amount  NUMERIC(12,2),      -- gross * 0.45
  platform_amount NUMERIC(12,2),      -- gross * 0.55
  metadata        JSONB DEFAULT '{}',
  created_at      TIMESTAMPTZ DEFAULT NOW()
);

API Endpoints

Example Revenue Calculation

The NovaReelOS Ads Platform is a full-stack programmatic advertising engine built to serve ads natively across every surface — video feed, LIVE streams, creator shops, and music discovery. All ad revenue flows through the unified 45/55 monetization engine, ensuring creators earn on every impression delivered against their content.

Auction Engine

Ad placement is determined by a second-price auction (Vickrey auction). Advertisers submit sealed bids per impression opportunity. The highest bidder wins but pays the second-highest bid price plus one cent, incentivizing truthful bidding and fair pricing.

Delivery Engine

Once an auction is won, the delivery engine manages pacing, frequency, and budget constraints to ensure campaigns spend evenly and viewers are not over-saturated.

Targeting

• Audience Segments — age, gender, language inferred from profile and engagement signals
• Interest-Based — derived from consumption patterns: music, fashion, food, gaming, fitness, tech
• Geographic — country, region, metro-level via IP geolocation and profile location
• Device — mobile vs. desktop, OS family (iOS/Android/Web), screen size buckets
• Content-Type — align ads to creator niche and content_type for contextual relevance

Brand Safety

• Content Category Exclusions — advertisers block categories (politics, adult, gambling) at campaign level
• Creator Verification Gates — only Verified creators (is_verified = true) eligible for premium ad tiers
• Advertiser Blocklists — creators exclude brands/industries via marketplace_settings.excluded_brands

Ad Formats

Ad Delivery Flow

The Brand Marketplace is a two-sided platform connecting brands with creators for sponsored content deals. Brands create campaigns with defined goals, budgets, and surface requirements. Creators discover campaigns, submit applications, or receive direct offers. All payments flow through the 45/55 monetization engine with full FTC disclosure tracking.

Campaign Lifecycle

Creator Matching Algorithm

When a brand creates a campaign, the platform scores eligible creators using a weighted composite of five signals to produce a ranked match list.

Pricing Model

Creators set their own rates per surface via the creator_rates table. Each row stores a creator_id, surface (video, short, campaign, series, event), and price. Brands propose a proposed_pay on each offer. If below the creator's rate, negotiation happens via the DM thread auto-created by the hire_requests system.

Campaign Analytics

• Campaign Performance — impressions, clicks, conversions, and cost-per-action per campaign
• Creator ROI — return on spend per creator, engagement generated vs. amount paid
• Spend Efficiency — budget utilization, CPM, cost-per-engagement metrics
• Audience Reach — unique viewers, demographic breakdown, geographic distribution

Data Model

The Creator Dashboard is the command center for every creator on NovaReelOS. It surfaces real-time earnings, content analytics, growth tools, and profile management in a single unified interface. Server-rendered with EJS, it pulls data from db/monetization.js, db/posts.js, and db/creators.js.

Earnings View

Revenue is displayed in real time across all monetizable surfaces. The earnings card shows gross revenue, the 45/55 split breakdown, and a payout preview sourced from the revenue_events table via getRevenueSummaryByCreator.

Analytics

• View Counts — total and per-post views from posts.view_count
• Likes — aggregate like count from posts.like_count and content_likes
• Follower Growth — net new followers over time from follows table timestamps
• Engagement Rate — rolling average of (likes + comments) / views as a trend line

Growth Tools

Content Scheduling

Creators set posts.scheduled_for to a future timestamp. The jobs/scheduled-publish.js cron finds posts with status = 'scheduled' and scheduled_for <= NOW(), transitioning them to 'published'.

TikTok Import

Creators paste a TikTok URL to import content. services/tiktok-download.js fetches the video, uploads to Polsia R2, and creates a post with source_tiktok_url for attribution.

Draft Management

Posts with status = 'draft' are visible only to the owner. Managed via getDraftsByCreator, publishPost, and updatePost.

Profile Management

Creators manage their public identity through creator_profiles: handle, name, bio, avatar, banner, niche, and content type. The Verified badge (is_verified) is toggled by admins via /admin/pipeline and renders as a cyan checkmark.

Onboarding Widget

Content Permissions

Each post carries six permission flags controlling interaction. Defaults are privacy-protective: downloads and reposts off, credit required, commercial use blocked.

Push Notifications

PWA web push via push_subscriptions. Notifications fire for new DMs, hire requests, post likes, and follower milestones. Stored per-creator per-endpoint with p256dh and auth keys for VAPID delivery.

The LIVE Studio powers real-time streaming on NovaReelOS. Creators start sessions, invite multi-guest panels, run interactive polls and goals, insert ad breaks, and overlay customizable stream widgets — all managed through db/live-tools.js and persisted in Neon PostgreSQL.

Streaming Sessions

A creator starts a LIVE session by inserting into live_sessions with a title and status = 'active'. The slow_mode_interval (seconds; 0 = disabled) throttles chat during high traffic. Ending sets ended_at and transitions status to 'ended'.

Multi-Guest

Each session supports up to 4 concurrent guests in live_guests. Guests have roles (guest or cohost) and progress through: pending (invited) -> approved (on-screen) -> removed (kicked). Hosts toggle mic_muted and camera_off per guest.

Polls

Hosts launch real-time text polls via live_polls. Each poll has a question, JSONB options array, and optional duration_seconds timer. One vote per viewer per poll is enforced by unique constraint on voter_id + poll_id in live_poll_votes. Status transitions from active to ended on timer expiry or manual close.

Goals

Creators set engagement goals using live_goals. Four types: followers, likes, gifts, and watch_time. Each tracks target_value vs. current_value with status active or completed. Progress renders via the goal widget overlay.

Ad Breaks

Hosts trigger 15-30 second ad insertions served via the Ads Platform auction engine (Section 06). Revenue flows through the 45/55 split as a revenue_event with surface = 'live'. Earnings appear in the creator dashboard within seconds.

Widget Overlays

Stream widgets are visual overlays stored in stream_widgets with positioning (position_x, position_y, width, height, z_index) and visibility toggle.

Creators save frequently-used configurations as reusable widget_templates (scoped per creator_id), loadable into any new session with a single click.

LIVE Shopping

Creators showcase products from their storefront with a click-to-buy overlay during LIVE. Viewers see product cards pinned to the stream with name, price, and purchase CTA. Revenue flows through 45/55 with surface = 'live_shop'.

Shop & Commerce transforms every creator profile into a storefront. Creators list physical merchandise, digital products, and exclusive content for sale directly within NovaReelOS. All transactions flow through the unified 45/55 revenue split — creators keep 45% of every sale, platform retains 55% for payment processing, hosting, and fulfillment.

Product Listings

• Physical Goods — merchandise (apparel, accessories, prints) with shipping address collection and tracking integration
• Digital Products — downloadable content (presets, tutorials, templates, exclusive videos) with instant delivery via signed R2 URLs

In-Feed Shopping

Products tagged in video posts enable native purchase flow without leaving the feed. Tapping a tag opens a bottom-sheet with product card (name, price, "Buy Now" CTA). Purchases are attributed to the specific post for per-content sales tracking.

Conversion Tracking

Full-funnel attribution from impression to purchase, with each step logged for analytics:

Boost System

The Shop surface integrates with the Ads Platform (Section 06) for paid promotion:

• Creator-Paid Boost — creator spends from earnings balance to promote their product higher in feed and search
• Brand-Sponsored Boost — brand pays to promote a creator's product as part of a marketplace campaign via the standard ad auction

Boosted products are labeled Promoted and subject to the same frequency capping and brand safety rules as all ad formats.

Revenue Model

All shop transactions are recorded as revenue_events with surface = 'shop'. The services/monetization.js engine calculates the split:

Creator Storefront

Each creator's shop is a dedicated profile tab with a curated product grid, featured items, and category filters. Creators pin up to 3 featured products (mirroring the is_pinned + pinned_order pattern from posts). The storefront URL is shareable externally, driving traffic from other platforms into the NovaReelOS commerce funnel.

Music is a first-class monetization surface in NovaReelOS. Creators upload original tracks, build playlists, and earn revenue through streaming plays and audio ad impressions -- all flowing through the unified 45/55 revenue split. The music surface sits alongside video, LIVE, and shop as a standalone earning channel within the platform.

Track Uploads & Catalog

Creators upload audio files (MP3, AAC, WAV) through the media API. Each track is stored on Polsia R2 and associated with the creator's profile. Track metadata includes title, genre, duration, cover art, and an optional link back to the creator's video content. Tracks appear in the music feed surface, discoverable via search, genre browsing, and algorithmic recommendation.

• Upload pipeline: Audio file → R2 storage → metadata record → feed indexing
• Supported formats: MP3 (up to 20MB), AAC, WAV (up to 60MB)
• Metadata fields: title, artist, genre, duration, cover_url, bpm, key, mood tags
• Visibility: Public by default; creators can set tracks to unlisted or follower-only

Playlists

Three playlist types drive music discovery and engagement:

• Creator-curated: Manually assembled by creators; pinned to profile, shareable
• Algorithmic: Generated from listening history, genre affinity, and trending signals
• Sponsored: Brand-funded playlists featuring curated tracks with sponsored interstitials

Ad Monetization

Audio ads are inserted between tracks in non-premium listening sessions. Sponsored playlists carry branded audio bumpers at the start and midpoint. All ad impressions are tracked as revenue events and routed through the monetization engine.

Licensing & Rights

Tracks uploaded to NovaReelOS are available for use in video posts by other creators, with automatic attribution tracking. When a track is used in a video, the original artist receives a share of the video's ad revenue proportional to usage. Rights management follows a simple model:

• Ownership: Creator retains full ownership of all uploaded music
• Platform license: Non-exclusive license for in-app playback and video sync
• Attribution: Automatic credit link to original artist on every video using the track
• Commercial use: Opt-in flag; brands must negotiate separate licensing for ads

Revenue Flow

Stream Play / Ad Impression
    ↓
revenue_events(surface='music', event_type='stream' | 'audio_ad')
    ↓
calculateRevenueSplit(gross_amount)
    ↓
creator_amount = gross × 0.45    platform_amount = gross × 0.55
    ↓                                ↓
Creator Payout Queue            Platform Revenue

Safety is foundational to NovaReelOS. The platform provides comprehensive tools for content moderation, creator protection, privacy compliance, and legal obligations. The Safety Center at /safety-center serves as the unified hub for all safety controls.

Safety Center

Six control cards give creators and moderators immediate access to safety features:

Moderation Pipeline

Content Upload / Comment / Message
        ↓
Automated Scanning (keyword filter + hash matching)
        ↓
  ⌊ PASS ⌋          ⌊ FLAG ⌋            ⌊ BLOCK ⌋
Published      Manual Review Queue     Rejected + Notify
                    ↓
              Moderator Decision
              ↓            ↓
           Approve        Remove + Strike
                            ↓
                       Appeal Process (72h window)

Privacy Controls

Per-post permissions give creators fine-grained control over content distribution:

• allow_download Gate download button (default: off)
• allow_repost Allow repost to other profiles (default: off)
• allow_external_share Show share-to-external button (default: on)
• require_credit Require attribution on reposts (default: on)
• allow_noncommercial Permit non-commercial reuse (default: on)
• allow_commercial Permit commercial reuse (default: off)

GDPR & DMCA Compliance

Full compliance with GDPR and DMCA is tracked through dedicated database tables and the compliance_audit_log. All moderation actions, data requests, and legal decisions are recorded immutably for audit.

• GDPR requests: access, erasure, portability, rectification, restrict -- stored in gdpr_requests
• DMCA: Takedown and counter-notice flow via dmca_requests (status: pending → reviewing → resolved/dismissed)
• Cookie consent: Per-visitor consent log with category breakdown in cookie_consent
• Audit trail: Every action logged to compliance_audit_log with actor, target, and detail JSONB

Creator Bill of Rights

Published at /bill-of-rights, the Creator Bill of Rights codifies immutable platform guarantees: revenue transparency (45/55 split always visible), data portability (full export within 72 hours), algorithmic fairness (no shadow-banning, public moderation decisions), and safety protections (emergency tools, appeal rights, wellbeing features).

NovaReelOS uses Neon PostgreSQL (serverless) for all relational data and Polsia R2 for media object storage. The database connection is managed through a single shared pool in db/index.js -- the only file permitted to instantiate new Pool().

Schema Overview

The database contains 38 tables organized across 8 domains:

Data Warehouse & Analytics

Analytics queries live in two dedicated modules. db/analytics.js provides aggregate queries for pipeline, creator, and ROI metrics. db/digest.js powers the daily digest across 7 sections: overview KPIs, pipeline status, creator performance, recent prospects, creator activity, alerts, and creator network stats.

Revenue Events ETL

Monetization Action (stream, ad view, brand deal, tip)
    ↓
processMonetizationEvent()  ←  services/monetization.js
    ↓
INSERT → revenue_events(creator_id, surface, event_type, amounts)
    ↓
getRevenueSummaryByCreator()  →  Dashboard aggregation
getPlatformRevenueSummary()  →  Admin reporting

Media Storage

• Provider: Polsia R2 (S3-compatible, CDN-backed)
• Video upload: POST /api/media/upload -- MP4, WebM, MOV -- max 60MB
• Image upload: POST /api/media/banner-upload -- JPEG, PNG, WebP, GIF -- max 5MB (base64 JSON)
• Output: Public CDN URL returned on success; stored in post or profile record

Migrations

Schema changes are managed through JavaScript migration files in the migrations/ directory. Files are named <unix-timestamp>_<name>.js and executed sequentially at startup via npm run migrate. The migrate runner skips .sql files.

NovaReelOS exposes a RESTful API layer under /api/* for all client interactions. Authentication uses three methods depending on context: magic link tokens for passwordless login, creator_token headers for API calls, and cookie-based brand auth for business dashboard sessions.

Authentication

• Magic links: POST to create token → email link → 15-minute expiry → single-use → sets session cookie
• Creator token: X-Creator-Token header; stored in creator_profiles.creator_token
• Brand auth: Cookie-based via businesses.auth_token; set on business login

REST API Endpoints

Event Tracking

TikTok Events API v1.3 integration fires non-blocking server-side events for conversion tracking. The client-side utility (public/js/tiktok.js) captures ttclid from URL params and persists it in a 90-day cookie. Server-side dispatch via services/tiktok-events.js sends SHA-256 hashed identifiers with each event.

Ad Sales Engine SDK

The Ad Sales Engine SDK documentation is published at /docs/ad-engine with a 10-section technical reference covering architecture, initialization, core modules, API reference, event types, revenue calculation, brand safety, and code examples. The SDK handles ad placement, impression tracking, and revenue event generation across all monetization surfaces.

NovaReelOS runs as a single Express.js process on Render, backed by Neon PostgreSQL for data and Polsia R2 for media storage. The architecture prioritizes simplicity -- one deployable unit, one database, one object store -- while maintaining horizontal scalability through stateless request handling and connection pooling.

Architecture Diagram

                     ⌊ Git Push ⌋
                         ↓
                  Render Auto-Deploy
                         ↓
              npm install → npm run migrate → npm start
                         ↓
            +--------------------------+
            |    Express.js Process    |
            |   (server.js entry)      |
            +-----+--------+----------+
                  |        |          |
           +------+   +---+---+  +---+------+
           | Neon |   | R2    |  | TikTok   |
           | PgSQL|   | Media |  | Events   |
           +------+   +-------+  +----------+

Hosting Stack

CI/CD Pipeline

Deployment is triggered by pushing to the main branch. Render watches the repository and automatically builds and deploys on every push. The build sequence is:

# Build command
npm install

# Start command
npm run migrate && npm start

# Migrations run at startup before the server binds
# JavaScript files in migrations/ executed sequentially
# .sql files are skipped by the migrate runner

Environment Variables

Scaling & Observability

• Horizontal scaling: Stateless Express.js process scales via Render's auto-scaling; add instances with no code changes
• Connection pooling: db/index.js manages a shared PostgreSQL pool; prevents connection exhaustion under load
• Health check: GET /health endpoint returns 200 with uptime, timestamp, and database connectivity status
• Logging: Structured application logs streamed to Render's log aggregator; console.log/error for all output
• Error handling: Express error middleware catches unhandled rejections; 500 responses include request IDs for debugging
• Zero-downtime deploys: Render performs rolling deploys; old process handles in-flight requests while new process starts

Auth Architecture

NovaReelOS uses a passwordless authentication model. No user passwords are stored anywhere in the system—eliminating credential-stuffing and breach-related vulnerabilities entirely. Authentication flows through three mechanisms.

// db/auth.js — magic link flow
async function createMagicLinkToken(email, creatorId) {
  const token = crypto.randomUUID();
  const expiresAt = new Date(Date.now() + 15 * 60 * 1000); // 15 min
  await pool.query('INSERT INTO magic_link_tokens ...');
  return token;
}

Fraud Prevention

• SQL Parameterization — All queries use $1, $2 placeholders via pg driver. No string concatenation touches SQL.
• Input Validation — Enum fields (stage, status, project_type) checked against whitelists at the route level.
• Rate Limiting — Auth endpoints and form submissions throttled to prevent brute-force attacks.
• CSRF Protection — Cookie-based auth uses SameSite and HttpOnly flags.

Brand & Creator Safety

The Ad Sales Engine enforces brand safety through content category filtering and advertiser blocklists. Creator verification gates ensure only trusted profiles enter premium campaigns.

• Content Permissions — Per-post controls: allow_download, allow_repost, allow_external_share, require_credit, allow_commercial.
• LIVE Moderation — Slow mode, guest approval/removal, chat moderation, one-click stream termination.
• Reporting — Six-step flow via Safety Center with category selection, evidence upload, and resolution tracking.

Data Protection & Infrastructure

GDPR compliance is built into the data layer. The gdpr_requests table tracks all data subject requests (access, erasure, portability, rectification, restrict). The compliance_audit_log records every privacy-relevant action. Cookie consent tracked per visitor in cookie_consent.

• HTTPS Everywhere — All traffic encrypted via Render TLS termination.
• Environment Secrets — Database URLs, API tokens, pixel IDs stored as Render env vars. Never committed to source.
• Single Pool — db/index.js is the only file that instantiates new Pool().

Revenue Split: The Economic Constitution

The 45/55 split is hardcoded into services/monetization.js and applies uniformly across all revenue surfaces. No admin panel can override it, no enterprise deal can customize it, and no investor pressure can alter it without a code change visible in version control.

Revenue Streams

5-Year Financial Projections

Unit Economics

• CAC — Target $8 per creator via organic TikTok campaigns and referral loops. Tracked via CompleteRegistration events.
• LTV — Projected $240 per creator over 24 months based on blended ad revenue, brand deal commissions, and shop fees at the 55% platform rate.
• LTV:CAC Ratio — Target 30:1, driven by near-zero marginal cost per additional creator.
• Break-Even — Month 18 with 50K active creators at $10/month average gross revenue. The 55% platform share ($275K/month) covers infrastructure, moderation, and operations.

Platform Evolution

NovaReelOS follows a phased rollout that prioritizes core creator value before expanding into adjacent revenue surfaces and international markets. Each phase builds on the infrastructure established in the previous one.

Phase 1 Highlights (Shipped)

• Server-rendered monolith on Express.js + EJS + Neon PostgreSQL
• Magic link passwordless auth with 15-minute single-use tokens
• Creator profiles with verification badges, follow graph, and niche filtering
• Video feed with drafts, scheduling, pinning, and granular post permissions
• Unified monetization engine with hardcoded 45/55 split across all surfaces
• Brand intake pipeline (prospect → qualified → active → paused/lost)
• GDPR, DMCA, and cookie consent compliance built into data layer

Phase 2 Focus (Current)

• Brand marketplace with campaigns, offers, applications, and creator rates
• Ad sales engine with programmatic auction, targeting, and brand safety
• LIVE studio with stream widgets, polls, goals, slow mode, multi-guest
• Revenue dashboard with real-time earnings breakdown by surface

Long-Term Vision

By 2028, NovaReelOS will be a fully composable creator operating system where every component—content, commerce, community, and capital—is owned by the creator and portable across platforms. The 45/55 split remains immutable regardless of scale.

Platform Policies

NovaReelOS operates under a layered policy framework. All policies are published as versioned legal documents stored in the legal_documents table.

• Terms of Service — Platform usage, content ownership, liability, dispute resolution.
• Privacy Policy — Data collection, processing, storage. Aligned with GDPR and CCPA.
• Community Guidelines — Acceptable content standards, prohibited behaviors, enforcement.
• Creator Bill of Rights — Immutable guarantees: transparent revenue, data portability, content ownership, fair appeals.

Content Policies & Moderation

• Moderation — Content evaluated against guidelines. Violations result in warnings, removal, or suspension.
• Appeals — Tracked in dmca_requests (IP claims) and support tickets (guideline disputes) with transparent status.
• Transparency — Regular reports on removals, account actions, and DMCA volume sourced from compliance_audit_log.

Document Versioning

Each document is identified by a unique (slug, version) pair with an is_current flag. Previous versions remain accessible for audit purposes.

-- legal_documents versioning model
CREATE TABLE legal_documents (
  slug            TEXT NOT NULL,           -- 'terms-of-service'
  version         TEXT NOT NULL,           -- '2.1.0'
  content         TEXT NOT NULL,
  effective_date  DATE,
  is_current      BOOLEAN DEFAULT false,
  UNIQUE(slug, version)
);

Creator Advisory & Compliance

Policy changes affecting creator economics go through a public comment period. Material changes to the Creator Bill of Rights require explicit acknowledgment.

Appendix A: Database Entity Reference

Appendix B: API Endpoint Glossary

Appendix C: Glossary of Terms

Appendix D: Configuration Reference