How Factory Scaled Next.js to Tens of Millions of Requests

Concept 1: Next.js as a Full-Stack Backend (Not Just a Frontend Framework)

What most people think:

Next.js = a tool for building user interfaces

What Factory demonstrates:

Next.js can power an entire backend infrastructure, including:

Why this matters:

• One codebase handles everything
• No need to spin up separate backend services
• New routes can be added instantly without new vendor decisions

💡 Key Takeaway: A single Next.js app can scale to tens of millions of daily requests when deployed on the right platform

---

Concept 2: Serverless Cold Starts and How "Fluid Compute" Solves Them

The Problem First:

Traditional serverless functions have a cold start penalty

User Request → Function is "sleeping" → Wake up (delay) → Process → Respond
                                           ↑
                                    This delay hurts latency

The Solution:

Fluid Compute keeps functions warm between requests

User Request → Function already warm → Process immediately → Respond
                                              ↑
                                        No wake-up delay

Real-World Result for Factory:

• p95 response time = 350ms or below
• Latency-sensitive workloads remain reliable at scale

💡 Key Takeaway: Cold starts are a hidden tax on serverless performance. Keeping functions warm eliminates this tax

---

Concept 3: Empowering Non-Technical Teams Through Autonomous Deployment

The Old Workflow (The Bottleneck):

Non-technical team needs a tool
        ↓
Submit request to engineering
        ↓
Engineers context-switch from product work
        ↓
Build and deploy the tool
        ↓
Days/weeks lost

The New Workflow (Factory's Model):

Non-technical team needs a tool
        ↓
Use AI Droids via Desktop App or CLI
        ↓
Droids call Vercel's APIs programmatically
        ↓
Tool is built and deployed autonomously
        ↓
Engineers only review high-stakes decisions

What this produces:

• ✅ Dozens of deployments per day
• ✅ Internal analytics dashboards
• ✅ Customer-specific demos built in minutes
• ✅ Custom one-off utilities

💡 Key Takeaway: When deployment is programmable via APIs, non-technical teams become self-sufficient, freeing engineers to focus on core product work

---

Concept 4: Security at the Network Layer (WAF + Observability)

The Threat That Emerged:

Opening self-serve signups introduced a new attack surface:

Self-serve signup enabled
        ↓
Bots discovered the open door
        ↓
Fraudulent account creation
        ↓
Bad IP floods hitting the API

The Two-Layer Defense:

Layer 1 — Observability (See the threat)

Traffic hits API
    ↓
Observability tools surface:
  - Unusual traffic patterns
  - Problematic IP addresses
  - Anomalous request volumes

Layer 2 — WAF Enforcement (Stop the threat)

Identified threat
    ↓
Web Application Firewall applies:
  - Route-level blocking rules
  - Rate limiting
  - DDoS protection (always running)

The Outcome:

"Tens of millions of requests daily and I'm not losing sleep over what's hitting the API"

💡 Key Takeaway: Security should operate at the network layer automatically — not require constant manual intervention from your engineering team

---

Concept 5: The "Eat Your Own Dog Food" Product Loop

What Factory Does:

They use their own product to build their product

Build internal automation using Droids
        ↓
Stress-test it on real infrastructure
        ↓
Validate it works at scale
        ↓
Ship it as a product feature
        ↑_________________________|
              Repeat

Why This Is Powerful:

💡 Key Takeaway: Using your own product internally creates a feedback loop that simultaneously improves the product AND reduces internal overhead

---

Summary: The Five Concepts at a Glance

┌─────────────────────────────────────────────────────────┐
│  1. Next.js as full-stack backend → One codebase scales  │
│  2. Fluid Compute → Eliminates cold start latency        │
│  3. Programmable deployment → Non-technical autonomy     │
│  4. WAF + Observability → Automatic security layer       │
│  5. Dogfooding loop → Product improves itself            │
└─────────────────────────────────────────────────────────┘

The overarching theme connecting all five concepts:

Stay lean by making infrastructure invisible — so engineers can focus entirely on building the product that matters