Phony Cloud Platform - Roadmap

Overview

This roadmap provides a week-by-week implementation plan starting March 2026. The strategy follows three phases that build upon each other.

┌─────────────────────────────────────────────────────────────────────────┐
│                    PHONY IMPLEMENTATION STRATEGY                         │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  PHASE 1: OPEN SOURCE FOUNDATION (Mar-Jun 2026)                         │
│  ══════════════════════════════════════════════                         │
│  Goal: Become the best Faker alternative for PHP/Laravel                │
│  Revenue: $0 (community building)                                        │
│                                                                          │
│         │                                                                │
│         ▼                                                                │
│                                                                          │
│  PHASE 2: CLOUD PLATFORM (Jul 2026 - Feb 2027)                          │
│  ═════════════════════════════════════════════                          │
│  Goal: Monetize with SaaS features OSS can't provide                    │
│  Revenue: $0 → $150K ARR                                                 │
│                                                                          │
│         │                                                                │
│         ▼                                                                │
│                                                                          │
│  PHASE 3: SCALE & ECOSYSTEM (Mar 2027+)                                 │
│  ═══════════════════════════════════════                                │
│  Goal: Language expansion, enterprise, exit preparation                  │
│  Revenue: $150K → $600K+ ARR → Exit                                      │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Phase 1: Open Source Foundation

Timeline: March - June 2026 (16 weeks) Goal: Establish the foundation with a language-agnostic training tool and PHP as first generation library

Architecture Decision

Training and Generation are SEPARATE concerns:

Training: Rust CLI (single tool for all languages, fast, MIT licensed)
Generation: Native per language (PHP first, then Python, TypeScript)

┌─────────────────────────────────────────────────────────────────────────┐
│  WHY THIS ARCHITECTURE                                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  • Training is one-time, generation is continuous → monetize speed      │
│  • Rust CLI is language-agnostic → PHP dev, Python dev, anyone can train│
│  • Native generation = easy install (composer/pip/npm), no FFI          │
│  • Same Rust core reused in Cloud → maximum performance where it's paid │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Repository Structure

┌─────────────────────────────────────────────────────────────────────────┐
│  PUBLIC REPOSITORIES (MIT Licensed)                                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  phonycloud/phony-core          Rust library (crates.io: phony-core)     │
│  ├── src/ngram/                N-gram training + generation algorithms  │
│  ├── src/model/                Model I/O (JSON + gzip)                  │
│  └── src/tokenizer/            Tokenization (char/word modes)           │
│                                                                          │
│  phonycloud/phony-cli           Rust CLI binary (crates.io: phony)       │
│  ├── src/commands/             train, info, validate, stats             │
│  ├── src/cloud/                login, generate, sync (→ API calls)      │
│  ├── models/                   Bundled pre-trained models               │
│  └── Cargo.toml                depends on phony-core                    │
│                                                                          │
│  phonycloud/phony-php           PHP generation library (Packagist)       │
│  phonycloud/phony-laravel       Laravel integration (Packagist)          │
│  phonycloud/phony-python        Python generation library (PyPI)         │
│                                                                          │
├─────────────────────────────────────────────────────────────────────────┤
│  PRIVATE REPOSITORY (Proprietary)                                        │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  phonycloud/cloud               Cloud Platform                            │
│  ├── dashboard/                Nuxt 3 (TypeScript + Vue)                │
│  ├── engine/                   Go backend (sync, mock API, jobs)        │
│  ├── rust/                     Cloud-specific Rust (FFI, optimizations) │
│  │   ├── src/ffi/              C ABI for Go (CGO)                       │
│  │   ├── src/flatbuffers/      Zero-copy model loading                  │
│  │   ├── src/parallel/         Parallel training (rayon)                │
│  │   └── Cargo.toml            depends on phony-core (git/crates.io)    │
│  └── infrastructure/           Terraform, Docker, CI/CD                 │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Month 1: Rust CLI Foundation (Weeks 1-4)

Week 1: Project Setup & N-gram Core

Deliverable	Description
Rust project structure	`phonycloud/phony-core` repo with core library
N-gram tokenization	Character-level Markov chain implementation
Frequency map building	Efficient storage of n-gram frequencies
Unit tests	100% coverage on core algorithms

Week 2: .phony Format & Training

Deliverable	Description
.phony format spec	gzipped JSON format, versioned, zero dependencies
Model metadata	N-gram size, training source, version, locale
CLI repo setup	`phonycloud/phony-cli` repo, depends on phony-core
`phony train` command	Train from txt, csv, json files
Format documentation	Spec published on phony.cloud/docs

Week 3: Model Commands & Validation

Deliverable	Description
`phony info` command	Display model metadata
`phony validate` command	Check model integrity
`phony stats` command	Show N-gram distribution statistics
Error handling	Clear error messages for all failure modes

Week 4: Pre-trained Models & Release

Deliverable	Description
tr_TR models	person_names, company_names, street_names, city_names
en_US models	person_names, company_names, street_names, city_names
de_DE models	person_names, company_names, street_names, city_names
Generic models	email_usernames, product_names, lorem_words
Install script	`curl -fsSL https://phony.cloud/install.sh \| sh`
crates.io publish	`phony-core` library + `phony` CLI binary
GitHub Release	v0.1.0 with binaries for Linux, macOS, Windows

Week 4 Milestone: phony-core + phony-cli published, works on all platforms, 5+ locales

Month 2: PHP Generation Library (Weeks 5-8)

Week 5: PHP Core Implementation

Deliverable	Description
Model loading	Read .phony format (gzipped JSON, native PHP)
N-gram generation	Weighted random walk algorithm (native PHP)
Seed support	Deterministic output for CI/CD
Composer package	`phonycloud/phony-php` structure

Week 6: PHP API Design

Deliverable	Description
Fluent API	`Phony::name()->first()`, `Phony::email()->generate()`
Custom models	`Phony::loadModel('/path/to/custom.phony')`
Constraints	Min/max length, prefix, suffix
Batch generation	Efficient for large volumes

Week 7: Laravel Integration

Deliverable	Description
Service Provider	Auto-discovery
Facade	`Phony::`
Factory integration	`fn() => Phony::name()->full()`
Config file	`config/phony.php`

Week 8: Laravel Commands & Traits

Deliverable	Description
`phony:generate` command	Generate data using seeder
`phony:models` command	List available models
PhonySeeder trait	Easy seeding
Packagist publish	`phonycloud/phony-php`, `phonycloud/phony-laravel`

Week 8 Milestone: PHP packages on Packagist, Laravel integration working

Month 3: Documentation & Community (Weeks 9-12)

Week 9: Documentation Site

Deliverable	Description
VitePress setup	phony.cloud/docs
Getting Started guide	Installation, first use, examples
CLI reference	All commands documented
PHP API reference	Full API documentation

Week 10: Tutorials & Examples

Deliverable	Description
Tutorial: Custom Models	Train your own models
Tutorial: Laravel Factories	Real-world factory examples
Tutorial: Locale Support	Multi-language data generation
Example repository	Complete example projects

Week 11: Community Launch Prep

Deliverable	Description
README polish	Clear value proposition
CONTRIBUTING.md	How to contribute
GitHub Issues templates	Bug reports, feature requests
Twitter/X account	@phonyland

Week 12: OSS Launch

Deliverable	Description
Product Hunt launch	Prepared assets
Hacker News post	Show HN
Laravel News pitch	Article submission
Reddit posts	r/php, r/laravel

Week 12 Milestone: Public launch, community engagement started

Month 4: Community Growth (Weeks 13-16)

Weeks 13-16: Iteration & Growth

Activity	Description
Bug fixes	Respond to community issues
Feature requests	Prioritize and implement
More locales	Add fr_FR, es_ES, pt_BR based on demand
Performance tuning	Optimize based on real usage
Blog posts	Technical deep-dives

Phase 1 Success Criteria:

[ ] phony-core published on crates.io
[ ] phony-cli published (GitHub releases, install script, crates.io)
[ ] .phony format spec documented
[ ] Pre-trained models for 5+ locales
[ ] PHP library on Packagist (phonycloud/phony-php) with 200+ weekly downloads
[ ] Laravel integration working
[ ] 500+ GitHub stars (across repos)
[ ] Featured in Laravel News or similar

Phase 2: Cloud Platform

Timeline: July 2026 - February 2027 (32 weeks) Goal: Monetize with features that require infrastructure

Implementation Order

Order	Feature	Weeks	Rationale
2.1	Platform Foundation	4	Everything depends on this
2.2	Schema-First Generation	3	Simpler than DB sync, validates core
2.3	Custom Model Training UI	2	Differentiator from competitors
2.4	Database Sync (MVP)	4	Core enterprise feature, MySQL only
2.5	Mock API (Read-Only)	3	Unique feature, no competitor has
2.6	Package Registry (MVP)	3	Community ecosystem, discoverability
2.7	Database Sync (Full)	3	PostgreSQL, incremental, scheduled
2.8	Mock API (Stateful)	2	After read-only proves valuable
2.9	Package Registry (Full)	2	Private packages, teams, analytics
2.10	Snapshots	3	Point-in-time captures
2.11	Python Library	3	Language expansion (lightweight)

2.1 Platform Foundation (Weeks 17-20)

Technical Stack:

DASHBOARD (Nuxt)                 GO ENGINE
├── Nuxt 3                       ├── Go 1.22+
├── Vue 3 + Composition API      ├── pgx (PostgreSQL)
├── TypeScript                   ├── go-mysql-driver
├── Tailwind CSS                 ├── net/http (API server)
├── Auth.js (authentication)     └── asynq (job queue)
├── Stripe SDK (billing)
└── Nuxt UI (components)

RUST (Cloud repo)                INFRASTRUCTURE
├── phony-core (via crates.io)   ├── PostgreSQL 15
├── FFI layer (C ABI → Go)       ├── Redis (cache, queue)
├── FlatBuffers (zero-copy)      └── S3-compatible storage
├── Parallel training (rayon)
└── N-gram engine (5M/sec)

Week 17: Auth & User Management

Deliverable	Description
User registration	Email/password + OAuth (GitHub, Google)
Login/logout	Session management
Password reset	Email flow
2FA setup	TOTP implementation

Week 18: Teams & Projects

Deliverable	Description
Organization model	Create, invite members
Role system	Owner, Admin, Developer, Viewer
Project model	Create, list, delete projects
API key management	Generate, revoke, scope

Week 19: Billing Foundation

Deliverable	Description
Stripe integration	Customer, subscription
Tier enforcement	Feature gating by plan
Usage tracking	Foundation for metering
Invoice management	Billing history

Week 20: CLI Cloud Commands

Deliverable	Description
`phony login`	OAuth flow
`phony logout`	Session end
`phony whoami`	Show current user/org
API client	Go client for CLI

Week 20 Milestone: Platform MVP deployed, users can sign up and pay

2.2 Schema-First Generation (Weeks 21-23)

Week 21: PDL Parser & Validation

Deliverable	Description
PDL JSON parser	Parse schema files
Schema validation	Validate against spec
Error messages	Clear validation errors
Generator resolution	Resolve generator references

Week 22: Generation Engine

Deliverable	Description
Rust core integration	FFI bridge to Go
Entity generation	Generate based on PDL
Relationship handling	FK integrity
Output formats	JSON, CSV, SQL

Week 23: Web UI & Export

Deliverable	Description
Schema upload	Web UI for PDL files
Visual preview	Sample generated data
Export options	Download in formats
`phony generate`	CLI generation command

Week 23 Milestone: Schema-first generation working in UI and CLI

2.3 Custom Model Training UI (Weeks 24-25)

Week 24: Training Sources

Deliverable	Description
File upload	TXT, CSV, JSON
Paste text	Quick training
Source preview	View before training
Training job queue	Async processing

Week 25: Model Management

Deliverable	Description
Model list	View all models
Model download	Export .phony file
Model versioning	Track versions
Team sharing	Share within org

Week 25 Milestone: Custom model training live for paid tiers

2.4 Database Sync MVP (Weeks 26-29)

Week 26: Connection Management

Deliverable	Description
MySQL connector	Connection pooling
SSH tunnel	Secure connection
Credential storage	Encrypted vault
Connection testing	Verify connectivity

Week 27: Schema Analysis

Deliverable	Description
Table introspection	List tables, columns
FK detection	Infer relationships
PII detection	Heuristic + pattern matching
Transform suggestions	Auto-suggest rules

Week 28: Sync Engine

Deliverable	Description
Full sync	Complete table copy
Streaming transform	Batch processing
Anonymization	Apply transforms
Progress tracking	Real-time status

Week 29: Sync UI & CLI

Deliverable	Description
Connection wizard	Step-by-step setup
Transform editor	Visual rule builder
`phony sync` command	CLI sync trigger
Sync history	View past syncs

Week 29 Milestone: Database sync working for MySQL

2.5 Mock API Read-Only (Weeks 30-32)

Week 30: API Generation

Deliverable	Description
PDL → REST mapping	Generate endpoints
Route generation	Dynamic routing
Response generation	Data from PDL
Deterministic output	Seed-based

Week 31: Hosting & Domains

Deliverable	Description
Subdomain routing	*.api.phony.cloud
CORS configuration	Cross-origin support
Rate limiting	Per-tier limits
Edge caching	Cloudflare integration

Week 32: Pagination & Auth Sim

Deliverable	Description
Pagination	Cursor + offset
Infinite scroll	Deterministic paging
API key simulation	Test auth flows
Bearer token simulation	JWT validation mock

Week 32 Milestone: Mock API read-only endpoints live

2.6 Package Registry MVP (Weeks 33-35)

Week 33: Registry Core

Deliverable	Description
Package model	Name, version, metadata
Upload API	Publish packages
Download API	Install packages
CLI integration	`phony packages install/publish`

Week 34: Search & Discovery

Deliverable	Description
Search engine	Full-text search
Browse UI	Category navigation
Package detail	Readme, stats
Version history	All versions

Week 35: Quality & Metrics

Deliverable	Description
Download metrics	Weekly/total
Semver validation	Enforce versioning
Dependency check	Validate deps
Documentation	How to publish

Week 35 Milestone: Public package registry live

2.7 Database Sync Full (Weeks 36-38)

Week 36: PostgreSQL Support

Deliverable	Description
PostgreSQL connector	Connection + introspection
Type mapping	PG-specific types
Copy command	Bulk loading
Testing	Full test suite

Week 37: Incremental Sync

Deliverable	Description
Timestamp-based	Updated_at tracking
Change detection	Compare checksums
Merge strategy	Update vs replace
Conflict handling	Resolution rules

Week 38: Scheduling

Deliverable	Description
Cron scheduler	Scheduled syncs
Webhook triggers	CI/CD integration
Notifications	Slack, email
Retry logic	Exponential backoff

Week 38 Milestone: PostgreSQL, incremental, scheduling complete

2.8 Mock API Stateful (Weeks 39-40)

Week 39: State Management

Deliverable	Description
State storage	Per-endpoint state
POST/PUT/DELETE	Mutation endpoints
State persistence	Configurable TTL
Reset API	Clear state

Week 40: Advanced Features

Deliverable	Description
Webhook simulation	Outbound hooks
Latency simulation	Configurable delays
Error simulation	Rate-based errors
Custom domains	Business tier

Week 40 Milestone: Stateful Mock API complete

2.9 Package Registry Full (Weeks 41-42)

Week 41: Private Packages

Deliverable	Description
Private visibility	Per-org packages
Access control	Team permissions
Scoped packages	@org/package-name
Billing integration	Tier enforcement

Week 42: Analytics & Badges

Deliverable	Description
Analytics dashboard	Usage metrics
Verified badges	Publisher verification
Dependency graph	Visual deps
Documentation	Complete guides

Week 42 Milestone: Full package registry with private packages

2.10 Snapshots (Weeks 43-45)

Week 43: Snapshot Core

Deliverable	Description
Full snapshot	Complete DB capture
Storage	S3-compatible
Encryption	Envelope encryption
Metadata	Manifest, checksums

Week 44: Restore & Incremental

Deliverable	Description
Full restore	Complete recovery
Table-level restore	Selective recovery
Incremental snapshots	Delta storage
Point-in-time	Precise restore

Week 45: Lifecycle & UI

Deliverable	Description
Retention policies	Tiered storage
Scheduled snapshots	Auto-create
Diff comparison	Compare versions
Schema drift detection	Track changes

Week 45 Milestone: Snapshots feature complete

2.11 Advanced Data Generation (Weeks 46-48)

These features differentiate Phony from basic faker libraries and provide production-quality synthetic data.

Week 46: Linked Generators & Consistency

Deliverable	Description
Linked generator engine	Multi-column coherent generation (city+country+postal)
Consistency system	Same input → same output across tables/databases
Format-preserving encryption	Automatic PK/FK consistency
Geographic data linking	Valid location combinations with coordinates

Week 47: Statistical Generators

Deliverable	Description
Categorical generator	Preserve frequency distributions
Continuous generator	Normal, lognormal, exponential distributions
Algebraic generator	Detect and preserve math relationships
Multivariate generator	Preserve correlations between columns

Week 48: Event Sequences & Cross-Table

Deliverable	Description
Event sequence engine	Chronologically valid date series
Cross-table operations	Sum, count, avg across related tables
Computed aggregates	Order totals = sum of line items
Conditional event logic	Branching timelines with probabilities

Week 48 Milestone: Advanced data generation features complete

2.12 Python Library (Weeks 49-51)

Week 46: Python Core

Deliverable	Description
.phony loader	Native Python
N-gram generation	Random walk
Seed support	Deterministic
PyPI package	`phony`

Week 47: Python API

Deliverable	Description
Fluent API	`Phony.name().first()`
Custom models	Load from file
Batch generation	Large volumes
Documentation	Full docs

Week 48: Framework Integrations

Deliverable	Description
pytest fixtures	Easy testing
FastAPI example	API integration
Django example	ORM integration
Cloud SDK	`phony-cloud`

Week 48 Milestone: Python library on PyPI

Phase 2 Success Criteria:

[ ] Internal production use (dogfooding)
[ ] 10+ beta customers using sync feature
[ ] 5+ paying customers
[ ] $30K+ ARR
[ ] <5% monthly churn
[ ] 50+ packages in registry

Phase 3: Scale & Ecosystem

Timeline: March 2027+ (ongoing) Goal: Enterprise readiness, language expansion, exit preparation

3.1 Enterprise Features

Category	Features
Auth	SSO (SAML, OIDC), SCIM provisioning, RBAC, IP allowlisting
Compliance	SOC2 Type II, GDPR docs, HIPAA BAA, Data residency
Deployment	Dedicated instance, VPC peering, On-premise, Air-gapped
Support	99.9%+ SLA, 24/7 support, Dedicated success manager

3.2 Additional Languages (Signal-Driven)

Decision Signals:

GitHub issues requesting language
Cloud customers asking for language
Gap in market (no good Faker alternative)
Strategic partnership opportunity

Candidates (Revenue-Optimized):

Language	Priority	Rationale
TypeScript	Optional Year 2	Huge ecosystem, browser support
Go	Future	Cloud-native
Ruby	Future	Rails ecosystem

3.3 Advanced Data Features

ARR Trigger	Features
$150K+	Differential Privacy: Mathematical privacy guarantees (ε-differential privacy), Laplace/Gaussian mechanisms, GDPR/HIPAA compliance certification
$200K+	Geo-Aware Generation: Lat/long fuzzing with k-anonymity, HIPAA Safe Harbor address generation, Population-aware postal code truncation
$250K+	Structured Data Masks: JSON path masking, XML XPath masking, Regex capture group transformation, HTML content redaction
$300K+	Format-Preserving Transformation: Character scramble (email, phone), Credit card masking (Luhn-valid), SSN/ID format preservation
$400K+	Database subsetting, NER-based PII detection, Automated data discovery
$600K+	Unstructured de-identification, Document redaction, Image/PDF anonymization
$1M+	Guided redaction workflows, Expert determination support, Compliance audit reports

3.4 Statistical & ML Features

ARR Trigger	Features
$300K+	Distribution Learning: Auto-detect distributions from source data, Histogram matching, Percentile preservation
$400K+	Correlation Preservation: Learn and preserve multi-column correlations, Covariance matrix replication
$600K+	AI Synthesizer: VAE-based deep learning for high-fidelity data synthesis, Automatic relationship detection

3.5 AI Agent Integration

Feature	Description
MCP Server	Model Context Protocol for AI agents
AGENTS.md	Agent integration documentation
llms.txt	LLM-readable documentation
OpenAPI Spec	Full API specification

Phase 3 Success Criteria:

[ ] $600K-1M+ ARR
[ ] 300+ paying customers
[ ] SOC2 Type II certified
[ ] At least 2 enterprise customers ($5K+/mo)
[ ] At least 1 additional language (if demand)
[ ] Exit-ready metrics

Dependency Graph

PHASE 1: FOUNDATION (Weeks 1-16)
══════════════════════════════════════════════════════════════════════════

  PUBLIC REPOSITORIES
  ───────────────────

  phonycloud/phony-core (Rust library, crates.io)
  │   ├── N-gram training + generation algorithms
  │   ├── Model I/O (JSON + gzip)
  │   └── Tokenization (char/word modes)
  │
  │   depends on ▼
  │
  phonycloud/phony-cli (Rust CLI, binary: phony)
  │   ├── train, info, validate, stats commands
  │   ├── cloud commands (login, generate, sync → API calls)
  │   └── Pre-trained models (tr_TR, en_US, de_DE, etc.)
  │
  │   .phony models used by ▼
  │
  phonycloud/phony-php (PHP generation library)
  │   (reads .phony models, native PHP generation)
  │
  │   extends ▼
  │
  phonycloud/phony-laravel (Laravel integration)
  │
  ▼
  Documentation + OSS LAUNCH (Week 12)

══════════════════════════════════════════════════════════════════════════

PHASE 2: CLOUD PLATFORM (Weeks 17-48)
══════════════════════════════════════════════════════════════════════════

  PRIVATE REPOSITORY: phonycloud/cloud
  ────────────────────────────────────

  phonycloud/phony-core ═══════════▶ cloud/rust/ (FFI + optimizations)
  (via crates.io/git)                  │
                                       ├── FFI layer (C ABI)
                                       ├── FlatBuffers (zero-copy)
                                       └── Parallel training
                                               │
                                               ▼ CGO
                                       cloud/engine/ (Go)
                                       │
                                       ├── Sync Worker
                                       ├── Mock API Server
                                       ├── Training Worker
                                       └── Export Manager
                                               │
                                               ▼
                                       cloud/dashboard/ (Nuxt)
  │
  ├── Platform Foundation (auth, billing, projects)      [Week 20]
  │
  ├── Schema-First ────▶ Custom Model UI                 [Week 25]
  │       │                    │
  │       └─────────┬──────────┘
  │                 │
  │                 ▼
  ├── Mock API (Read-Only) ────▶ Mock API (Stateful)    [Week 40]
  │
  ├── Database Sync (MVP) ────▶ Database Sync (Full)    [Week 38]
  │
  ├── Package Registry (MVP) ──▶ Registry (Full)         [Week 42]
  │
  ├── Snapshots                                          [Week 45]
  │
  └── phonycloud/phony-python (Python library)            [Week 48]

══════════════════════════════════════════════════════════════════════════

PHASE 3: SCALE (Year 2+, Signal-driven)
══════════════════════════════════════════════════════════════════════════

  phonycloud/phony-typescript (npm: @phonycloud/phony)
  │   (reads .phony models, native JS generation)
  │   (works in Node.js AND browser)
  │
  └── TypeScript Cloud SDK

  Enterprise Features
  ├── SSO (SAML, OIDC)
  ├── Audit logs
  └── On-premise option

  Advanced Data Features (if demand)
  ├── Database subsetting
  ├── NER for PII detection
  └── Unstructured data

CLI Command Reference

The phony CLI is a unified tool for both offline (free) and cloud (paid) operations.

┌─────────────────────────────────────────────────────────────────────────┐
│                    UNIFIED CLI (Single Binary: phony)                    │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  OFFLINE COMMANDS (Free, MIT Licensed, No Auth Required)                │
│  ═══════════════════════════════════════════════════════                │
│                                                                          │
│  $ phony train input.txt -o model.phony        # Train from file        │
│  $ phony train data.csv --column name          # Train from CSV column  │
│  $ phony info model.phony                      # Show model metadata    │
│  $ phony validate model.phony                  # Validate model format  │
│  $ phony stats model.phony                     # Show N-gram statistics │
│                                                                          │
│  CLOUD COMMANDS (Requires: phony login)                                 │
│  ════════════════════════════════════════                               │
│                                                                          │
│  $ phony login                                 # Authenticate with cloud│
│  $ phony logout                                # End session            │
│  $ phony whoami                                # Show current user/org  │
│                                                                          │
│  $ phony models                                # List cloud models      │
│  $ phony models push custom.phony              # Upload model to cloud  │
│  $ phony models pull en_US/names               # Download cloud model   │
│                                                                          │
│  $ phony sync                                  # Run sync job           │
│  $ phony sync --status                         # Check sync status      │
│                                                                          │
│  $ phony snapshot create --name "v1.2"         # Create snapshot        │
│  $ phony snapshot list                         # List snapshots         │
│  $ phony snapshot restore v1.2                 # Restore snapshot       │
│                                                                          │
│  $ phony mock start                            # Start local mock API   │
│  $ phony mock deploy                           # Deploy to cloud        │
│                                                                          │
│  $ phony generate users --count 1000           # Cloud generation (5M/s)│
│  $ phony generate --schema schema.yaml         # Schema-first generation│
│                                                                          │
│  $ phony packages install org/package          # Install package        │
│  $ phony packages publish                      # Publish package        │
│                                                                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  SIMILAR TO:  gh (GitHub CLI)    → gh auth login / gh repo create       │
│               vercel             → vercel login / vercel deploy         │
│               supabase           → supabase login / supabase db push    │
│                                                                          │
│  BENEFIT:     Single tool for entire workflow                           │
│               Offline-first (training always works without auth)        │
│               Progressive disclosure (cloud features unlock with login) │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Timeline Summary

Phase	Period	Duration	Key Milestones
Phase 1	Mar-Jun 2026	16 weeks	Rust CLI, PHP Library, Laravel, OSS Launch
Phase 2	Jul 2026-Feb 2027	32 weeks	Cloud Platform, All Features, Python Library
Phase 3	Mar 2027+	Ongoing	Enterprise, TypeScript, Scale

Monthly Checkpoints

Month	Date	Key Deliverable
Month 1	Apr 2026	Rust CLI v0.1.0 released
Month 2	May 2026	PHP packages on Packagist
Month 3	Jun 2026	Documentation complete
Month 4	Jul 2026	OSS community growing
Month 5	Aug 2026	Platform Foundation live
Month 6	Sep 2026	Schema-first + Model Training
Month 7	Oct 2026	Database Sync MVP (MySQL)
Month 8	Nov 2026	Mock API + Package Registry MVP
Month 9	Dec 2026	Full DB Sync + Stateful Mock API
Month 10	Jan 2027	Full Registry + Snapshots
Month 11	Feb 2027	Python Library complete
Month 12	Mar 2027	$150K ARR target, Phase 3 begins

Phony Cloud Platform - Roadmap ​

Overview ​

Phase 1: Open Source Foundation ​

Architecture Decision ​

Repository Structure ​

Month 1: Rust CLI Foundation (Weeks 1-4) ​

Week 1: Project Setup & N-gram Core ​

Week 2: .phony Format & Training ​

Week 3: Model Commands & Validation ​

Week 4: Pre-trained Models & Release ​

Month 2: PHP Generation Library (Weeks 5-8) ​

Week 5: PHP Core Implementation ​

Week 6: PHP API Design ​

Week 7: Laravel Integration ​

Week 8: Laravel Commands & Traits ​

Month 3: Documentation & Community (Weeks 9-12) ​

Week 9: Documentation Site ​

Week 10: Tutorials & Examples ​

Week 11: Community Launch Prep ​

Week 12: OSS Launch ​

Month 4: Community Growth (Weeks 13-16) ​

Weeks 13-16: Iteration & Growth ​

Phase 2: Cloud Platform ​

Implementation Order ​

2.1 Platform Foundation (Weeks 17-20) ​

Week 17: Auth & User Management ​

Week 18: Teams & Projects ​

Week 19: Billing Foundation ​

Week 20: CLI Cloud Commands ​

2.2 Schema-First Generation (Weeks 21-23) ​

Week 21: PDL Parser & Validation ​

Week 22: Generation Engine ​

Week 23: Web UI & Export ​

2.3 Custom Model Training UI (Weeks 24-25) ​

Week 24: Training Sources ​

Week 25: Model Management ​

2.4 Database Sync MVP (Weeks 26-29) ​

Week 26: Connection Management ​

Week 27: Schema Analysis ​

Week 28: Sync Engine ​

Week 29: Sync UI & CLI ​

2.5 Mock API Read-Only (Weeks 30-32) ​

Week 30: API Generation ​

Week 31: Hosting & Domains ​

Week 32: Pagination & Auth Sim ​

2.6 Package Registry MVP (Weeks 33-35) ​

Week 33: Registry Core ​

Week 34: Search & Discovery ​

Week 35: Quality & Metrics ​

2.7 Database Sync Full (Weeks 36-38) ​

Week 36: PostgreSQL Support ​

Week 37: Incremental Sync ​

Week 38: Scheduling ​

2.8 Mock API Stateful (Weeks 39-40) ​

Week 39: State Management ​

Week 40: Advanced Features ​

2.9 Package Registry Full (Weeks 41-42) ​

Week 41: Private Packages ​

Week 42: Analytics & Badges ​

2.10 Snapshots (Weeks 43-45) ​

Week 43: Snapshot Core ​

Week 44: Restore & Incremental ​

Week 45: Lifecycle & UI ​

2.11 Advanced Data Generation (Weeks 46-48) ​

Week 46: Linked Generators & Consistency ​

Week 47: Statistical Generators ​

Week 48: Event Sequences & Cross-Table ​

2.12 Python Library (Weeks 49-51) ​

Week 46: Python Core ​

Week 47: Python API ​

Week 48: Framework Integrations ​

Phase 3: Scale & Ecosystem ​

3.1 Enterprise Features ​

3.2 Additional Languages (Signal-Driven) ​

3.3 Advanced Data Features ​

3.4 Statistical & ML Features ​

3.5 AI Agent Integration ​

Dependency Graph ​

CLI Command Reference ​

Timeline Summary ​