Phony Cloud Platform - Solution
The Phony Ecosystem
Phony solves data problems with a unified platform:
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ PHONY PLATFORM │
│ │
│ "From your data to realistic synthetic data in minutes" │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ CORE INNOVATION: Statistical N-gram Learning │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Your Data ──▶ Learn Patterns ──▶ Generate Similar (Not Same) │ │
│ │ │ │
│ │ • Learns character/word distributions │ │
│ │ • Preserves statistical properties │ │
│ │ • Never reproduces original data │ │
│ │ • Works with ANY language │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ WHAT YOU CAN DO: │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Database │ │ Schema- │ │ Mock API │ │ Custom │ │
│ │ Sync & │ │ First │ │ Generation │ │ Model │ │
│ │ Anonymize │ │ Generation │ │ │ │ Training │ │
│ │ │ │ │ │ │ │ │ │
│ │ Prod → │ │ No source │ │ Instant │ │ Learn from │ │
│ │ Staging │ │ DB needed │ │ REST APIs │ │ your data │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘Platform Architecture
┌─────────────────────────────────────────────────────────────────────────┐
│ PHONY PLATFORM │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ INPUT MODES │ │
│ ├───────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ MODE A: Database Source MODE B: Schema-Only (No DB) │ │
│ │ ┌────────────────────┐ ┌────────────────────────────┐ │ │
│ │ │ │ │ │ │ │
│ │ │ Connect to your │ │ Define schema via: │ │ │
│ │ │ existing database │ │ • YAML/JSON │ │ │
│ │ │ │ │ • Visual Builder │ │ │
│ │ │ • MySQL/MariaDB │ │ • Laravel Migration │ │ │
│ │ │ • PostgreSQL │ │ • SQL DDL Import │ │ │
│ │ │ • SQLite │ │ │ │ │
│ │ │ │ │ No source database │ │ │
│ │ │ Learn patterns │ │ needed! │ │ │
│ │ │ from real data │ │ │ │ │
│ │ │ │ │ │ │ │
│ │ └────────────────────┘ └────────────────────────────┘ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ PHONY ENGINE │ │
│ ├───────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌────────────────────┐ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Pre-trained │ │ Custom │ │ Composition │ │ │
│ │ │ Models │ │ Models │ │ (PGDL + PEL) │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ • Names │ │ Train from │ │ Combine models, │ │ │
│ │ │ • Emails │ │ your data │ │ lists & logic │ │ │
│ │ │ • Addresses │ │ │ │ into structured │ │ │
│ │ │ • Phones │ │ Domain- │ │ records, docs, │ │ │
│ │ │ • Companies │ │ specific │ │ event sequences │ │ │
│ │ │ • Products │ │ patterns │ │ │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ └──────────────┘ └──────────────┘ └────────────────────┘ │ │
│ │ │ │
│ │ Speed: 100K+ records/sec Deterministic. No LLM in the loop. │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ OUTPUT MODES │ │
│ ├───────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ MODE 1 MODE 2 MODE 3 │ │
│ │ Database Target File Export Mock API │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────────┐ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Direct │ │ • SQL Dump │ │ REST Endpoints │ │ │
│ │ │ Insert │ │ • CSV │ │ │ │ │
│ │ │ │ │ • JSON │ │ GET /users │ │ │
│ │ │ • MySQL │ │ • Parquet │ │ GET /users/:id │ │ │
│ │ │ • Postgres │ │ • Laravel │ │ POST /users │ │ │
│ │ │ • SQLite │ │ Seeders │ │ PUT /users/:id │ │ │
│ │ │ │ │ • Factory │ │ DELETE /users │ │ │
│ │ │ │ │ Files │ │ │ │ │
│ │ │ Staging │ │ │ │ Mobile/Frontend │ │ │
│ │ │ Testing │ │ Version │ │ Development │ │ │
│ │ │ Local Dev │ │ Control │ │ Prototyping │ │ │
│ │ │ │ │ Sharing │ │ Testing │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────────┘ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘No LLM in the loop
Phony deliberately generates without any LLM at runtime. Generation is statistical (n-gram models + PGDL/PEL composition), which is what makes it fast, $0 per record, deterministic, and safe to run fully offline. A possible future convenience is LLM assistance for authoring PGDL configs (describe a schema, get a config draft) — an authoring aid only, never a generation engine.
Core Engine: Statistical Learning
How Phony Learns
Unlike Faker (static lists) or Tonic Fabricate (LLM), Phony uses N-gram statistical learning:
┌─────────────────────────────────────────────────────────────────────────┐
│ PHONY'S STATISTICAL ENGINE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ INPUT: Real Turkish Names │
│ ["Mehmet", "Ahmet", "Ayşe", "Fatma", "Özgür", "Çağla", ...] │
│ │
│ │ │
│ ▼ │
│ │
│ STEP 1: N-gram Extraction (n=2) │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ "Mehmet" → "Me", "eh", "hm", "me", "et" │ │
│ │ "Ahmet" → "Ah", "hm", "me", "et" │ │
│ │ "Ayşe" → "Ay", "yş", "şe" │ │
│ │ "Özgür" → "Öz", "zg", "gü", "ür" │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ │ │
│ ▼ │
│ │
│ STEP 2: Build Probability Model │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ "Me" → next: {"eh": 15, "li": 3, "rv": 1} │ │
│ │ "Ah" → next: {"me": 12, "ma": 5} │ │
│ │ "Ay" → next: {"şe": 8, "la": 4, "su": 2} │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ │ │
│ ▼ │
│ │
│ STEP 3: Generate (Weighted Random Walk) │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Start: "Me" → "eh" (prob 15/19) → "hm" → "me" → "et" → END │ │
│ │ Result: "Mehmet" (existing) or "Mehmetcan" (new!) │ │
│ │ │ │
│ │ Option: excludeOriginals=true → Never output exact matches │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ OUTPUT: Statistically similar but potentially novel names │
│ ["Mehmetcan", "Ayşenur", "Özlem", "Çağrı", "Ahmetan", ...] │
│ │
└─────────────────────────────────────────────────────────────────────────┘The distributions above are conceptual — an illustration of what the model learns. On disk, a trained model is a compact binary .ngram file (portable across every Phony runtime), not JSON.
Why This Matters
| Approach | How It Works | Result |
|---|---|---|
| Faker | Random pick from list | "John", "Jane", "Bob" (boring) |
| LLM | Generate from training | Creative but expensive, slow |
| Phony | Learn YOUR patterns | Matches YOUR data distribution |
Key Advantages
- Language Agnostic: Learns from ANY text - Turkish, Japanese, Klingon, domain jargon
- Fast: 100K+ generations/second (vs ~10/sec for LLM)
- Cheap: $0 per generation (vs $0.01+ for LLM)
- Deterministic: Same seed = same output (CI/CD friendly)
- Private: No data leaves your environment
- Never Reproduces Training Data:
excludeOriginals=trueoption
Built for the Agent Era
The primary "user" of a data library is increasingly a coding agent, not a human. Phony is designed for that reader:
| Agent-Era Need | Phony Answer |
|---|---|
Agents default to fake() (Faker saturates LLM training data) | Drop-in Faker API compatibility — one CLAUDE.md/AGENTS.md line ("use phony() instead of fake()") is the whole migration |
| Agent-written tests must stay reproducible | Deterministic seeds: same seed = same data, forever — no flaky fake data |
| Agents multiply usage without multiplying budget | Pricing never meters generation volume, users, or agents |
| Agents need a machine-readable surface | MCP server, AGENTS.md snippets, editor skills — never paywalled |
| Agents need realistic environments they can't damage | Ephemeral environments from snapshots: a prod-like database your coding agent can't leak PII from |
Open Source vs Cloud
The split is local-first: OSS is the full engine — everything that generates data runs locally, free, forever. Cloud sells the control plane: orchestration, visibility, and compliance around your data workflows. Even as a Cloud customer, the data plane (sync, anonymization, snapshots) runs in your infrastructure and the hosted control plane sees metadata only. The one hosted exception is the mock API, which serves synthetic data exclusively.
┌─────────────────────────────────────────────────────────────────┐
│ │
│ PHONY OPEN SOURCE PHONY CLOUD │
│ (Free Forever) (phony.cloud) │
│ ───────────────── ────────────── │
│ │
│ ✓ Full engine (Rust core, ✓ Everything in OSS, plus │
│ PHP port, bindings) the CONTROL PLANE: │
│ ✓ All generators, PGDL/PEL ✓ Web dashboard │
│ ✓ Pre-trained models ✓ DB sync & anonymization │
│ ✓ Local model training (runs in YOUR infra; │
│ ✓ CLI + git packages control plane = metadata) │
│ ✓ Laravel integration ✓ PII visibility & compliance │
│ ✓ Deterministic seeds reports (KVKK/GDPR packs) │
│ ✓ Faker compat + agent ✓ Snapshots & ephemeral envs │
│ surface (AGENTS.md, MCP) (stored in YOUR storage) │
│ ✓ Community support ✓ Scheduled jobs, team collab │
│ ✓ Hosted mock APIs (synthetic │
│ ✗ No orchestration/dashboard data only — the exception) │
│ ✗ No sync workflow product ✓ Enterprise: self-hosted │
│ ✗ No compliance reporting control plane │
│ │
│ License: MIT License: Commercial │
│ Hosted COGS: none Billed by connected sources │
│ │
└─────────────────────────────────────────────────────────────────┘Strategic Boundary: OSS = Full-Featured Faker Alternative
OSS provides:
- Modern Faker replacement with pre-trained models (plus a drop-in Faker API compatibility layer)
- N-gram engine for realistic data generation
- Local model training from files (txt, csv, json)
- Laravel-native integration
Cloud adds (control-plane value — your data stays in your infra):
- Orchestrated database sync & anonymization workflows
- PII findings, audit trail, compliance report packs
- Snapshot scheduling & ephemeral environments
- Team collaboration, model sharing & versioning
- Hosted mock APIs (synthetic data only)
Natural Upsell Path:
1. Developer uses Phony OSS with pre-trained models
2. Trains custom model from local file (names.txt)
3. Works great! Becomes Phony advocate.
4. Later: "I need anonymized prod data in staging — provably PII-free"
5. → Signs up for Phony Cloud (local-first DB sync)
6. → Also discovers snapshots, mock API, compliance reportsUse Cases: Where Synthetic Data Makes a Difference
High-quality synthetic data has a huge impact across the software development lifecycle:
1. QA Environments
Test data that looks, acts, and behaves like production data provides more accurate testing. QA environments can perform functional and non-functional testing with confidence when datasets can stand up to rigorous testing.
2. Debugging
Synthetic data enables:
- More accurate environments to reproduce production bugs
- Custom datasets with specific characteristics for unit testing
- Diverse datasets to test system limits
- Large datasets for load and performance testing
- Subsetting to narrow down specific rows causing issues
3. CI/CD & DevOps
Modern pipelines are built with automation baked in. Throughout a deployment pipeline, various stages can trigger automated tests. Synthetic data that mimics real-world ensures:
- Higher quality tests
- Fewer breaks in automation
- Improved MTTR (mean-time-to-release)
4. Product Demos
Software demos are one of the best ways to show off what you've built. But how can you demonstrate capabilities without sharing real data with untrusted third parties? Synthetic data creates impressive, realistic demos without exposing sensitive information.
5. Customer Support
Support teams need to resolve bugs but often lack full access to production data. Synthetic data provides:
- Subsets with custom filters to triage specific bugs
- Accurate environments to replicate customer-reported issues
- Multiple "persona" datasets representing customer segments
6. Machine Learning
Synthetic data for ML is as good as real data in 70% of experiments (MIT research). Benefits:
- Train ML models without privacy concerns
- Test complex ML pipelines
- Expand limited datasets with additional training data
- Add noise to create more comprehensive testing
- Remove bias by generating balanced datasets
OSS Strategy
Local model training is OPEN in OSS. Users can train custom models from local files without Cloud.
Why Open?
- N-gram algorithm is public knowledge (academic literature since 1990s)
- Real moat is the control plane: sync orchestration, PII visibility, compliance reporting, team features
- Open training builds trust → larger adoption → more Cloud conversions
Cloud's Unique Value
| OSS (Free) | Cloud (Paid) |
|---|---|
| Local file training | + Orchestrated DB column training (runs in your infra) |
| CLI only | + Web dashboard (sees metadata only) |
| Single user | + Team collaboration |
| No hosting | + Hosted mock API (synthetic data only — the one hosted exception) |
| Manual | + Scheduled jobs, PII visibility, compliance report packs |