Weldr for Development Agencies

Deliver MVPs 10x faster, then hand off with full client control

---

Why Weldr for Agencies?

You know the pain:

• Clients want MVPs yesterday - But quality takes time

• Scope creep is constant - "Just one more feature..."

• Handoff is messy - Clients hire other devs, break your code

• Maintenance is a burden - Small changes become expensive projects

Traditional approach: Build everything from scratch, lock clients into maintenance contracts, pray they don't customize without you. Weldr approach: Generate MVPs in hours, hand off with Extended mode (their custom code preserved forever), no maintenance lock-in.

---

The Agency Workflow

Week 1: Discovery & Generation

Old way (2-4 weeks):

Discovery meeting

Write requirements doc

Create mockups

Set up project (Next.js, database, auth, deployment)

Build database schema

Build authentication

Build CRUD operations

Build UI components

Weldr way (2-4 hours):

Discovery meeting (same)

Chat with Weldr during/after meeting

Watch live preview as app builds

Share preview with client for feedback

Iterate in real-time

Deploy

Time saved: 10-15 days per project Example - E-Commerce Client:

Discovery notes → Weldr chat:

"E-commerce site for handmade jewelry:
- Product catalog with categories (rings, necklaces, earrings)
- Shopping cart with guest checkout
- Stripe payment processing
- Order management with fulfillment tracking
- Customer accounts with order history
- Admin dashboard for inventory management
- Email notifications (order confirmation, shipping updates)"

[30 minutes later]
✅ Complete Next.js app running
✅ PostgreSQL database with all tables
✅ Stripe integration
✅ Auth with customer/admin roles
✅ Responsive UI with cart, checkout
✅ Admin dashboard
✅ Email templates

Client sees it working DURING the discovery call.

---

Week 2-3: Client Customization

Client inevitably needs custom features:

• "We need custom wholesale pricing for bulk orders"

• "We have a special loyalty program"

• "We integrate with our inventory system (custom API)"

Old way:

• Rebuild affected sections

• Risk breaking existing code

• Quote more hours

• Extend timeline

Weldr way:

# weldr.ownership.yaml
version: ownership/v2

surfaces:
  db: managed              # Let Weldr handle schema
  api: extended            # Mix generated + custom
  domain_logic: ejected    # Client owns pricing/loyalty
  ui: managed              # Keep UI automated

Your team adds custom code in @custom blocks:

// lib/server/actions/orders.ts (Extended mode)
/** @weldr surface: api mode: extended **/

// @weldr:begin crud-order
export async function createOrder(input: CreateOrderInput) {
  // Weldr regenerates this
  return await db.insert(orders).values(input);
}
// @weldr:end crud-order

// @custom:begin wholesale-pricing
export async function createWholesaleOrder(input: WholesaleOrderInput) {
  // YOUR custom code - never touched by Weldr
  const discount = await getWholesaleDiscount(input.customerId);
  const items = await applyBulkPricing(input.items, discount);

  const order = await createOrder({
    ...input,
    items,
    type: 'wholesale'
  });

  await notifyWarehouse(order);
  return order;
}
// @custom:end wholesale-pricing

Client changes their mind? Regenerate with Weldr - your custom code is preserved.

---

Week 4: Handoff & Future-Proofing

Old way:

• Hand off code

• Client hires another dev

• That dev changes something

• Everything breaks

• Client calls you to fix (or worse, blames you)

Weldr way:

# Set up Extended mode for client's future devs
surfaces:
  db: managed              # Weldr handles migrations
  api: extended            # Client devs can add @custom blocks
  domain_logic: ejected    # Client owns business logic
  ui: extended             # Can add custom components
  styling: ejected         # Client's design system

Client's new developer:

Reads the ownership manifest

Sees what's managed vs extended vs ejected

Adds custom code in @custom blocks

Regenerates with Weldr

Custom code preserved, database/routing updated

You're protected:

• Your generated code has leases (ownership headers)

• Client's custom code is in marked blocks

• Regeneration never breaks custom code

• TypeScript contracts validate everything still works

Result: Clean handoff, no maintenance burden, no blame when client customizes.

---

Real-World Agency Use Cases

Use Case 1: Rapid Prototyping for Sales

Scenario: You're pitching a $100k project. Client needs to "see something" before signing. Old way:

• Build a mockup (Figma, no real data)

• Client: "Can we click through it?"

• Build a prototype (fake data, no backend)

• Client: "Can we test with real data?"

• Weeks of back-and-forth before contract signed

Weldr way:

Discovery call (1 hour)

Generate working app with Weldr (1 hour)

Deploy to weldr-demo-clientname.vercel.app

Client tests with real data during sales process

Sign contract

Customize with Extended mode

Hand off

Win rate increase: Agencies report 40-60% higher close rates when demoing working apps vs mockups.

---

Use Case 2: Fixed-Price Projects

Scenario: Client wants fixed-price quote for a SaaS dashboard. Old way:

• Estimate: 8-12 weeks, $80k-$120k

• Reality: Scope creep, 14 weeks, $140k

• Client unhappy, you're unprofitable

Weldr way:

Generate MVP in Week 1 (flat $5k)

Show working app: "This is included in base price"

Client: "Can you add [feature]?"

You: "That's Extended mode - here's the pricing:"

- Managed features (schema, CRUD, UI): $500/feature - Extended features (custom API logic): $2k/feature - Ejected features (full custom modules): $5k/module

Scope creep becomes scope budget (profitable)

Agency pricing model:

Base MVP: $5k-$10k (1 week, mostly Weldr)
+ Extended features: $2k each (your code in @custom blocks)
+ Ejected modules: $5k each (full ownership)
+ Design customization: $3k (eject styling surface)
+ Integrations: $5k each (eject domain logic)
+ Deployment & training: $2k

Total: $15k-$30k for custom SaaS (vs $80k-$120k traditional)
Profit margin: 60-70% (vs 30-40% traditional)

---

Use Case 3: White-Label SaaS for Multiple Clients

Scenario: You build the same type of app for multiple clients (e.g., booking systems, CRMs, marketplaces). Old way:

• Build template codebase

• Fork for each client

• Maintain 10 different forks

• Bug fix needs to be applied 10 times

• Client customizations prevent updates

Weldr way: Step 1: Generate base template with Weldr

# base-booking-system/weldr.ownership.yaml
version: ownership/v2

surfaces:
  db: managed              # Schema standardized
  auth: managed            # Auth standardized
  api: extended            # Custom per client
  ui: extended             # Branding per client
  styling: ejected         # Design per client
  domain_logic: ejected    # Business rules per client

Step 2: Customize per client (Extended mode)

// client-a/lib/server/actions/bookings.ts
// @custom:begin client-a-pricing
export async function calculatePrice(booking: Booking) {
  // Client A's unique pricing (hourly + equipment fees)
  return booking.hours * HOURLY_RATE + getEquipmentFees(booking);
}
// @custom:end client-a-pricing

// client-b/lib/server/actions/bookings.ts
// @custom:begin client-b-pricing
export async function calculatePrice(booking: Booking) {
  // Client B's unique pricing (flat rate + membership discount)
  const base = FLAT_RATE;
  const discount = await getMembershipDiscount(booking.customerId);
  return base - discount;
}
// @custom:end client-b-pricing

Step 3: Update base template

• Weldr regenerates for all clients

• Each client's custom code preserved

• Schema updates applied across all clients

• New features added to all clients

Result:

• 10 clients with custom features

• 1 maintained codebase

• Updates deploy to all clients

• Each client can further customize

Revenue model:

• Base setup: $5k per client (1 day, mostly automated)

• Custom features: $2k-$5k per client

• Monthly maintenance: $500/client (includes Weldr updates)

• 10 clients = $50k setup + $5k/month recurring

---

Use Case 4: Technical Due Diligence

Scenario: Client's existing app is a mess. They want you to rebuild it. Old way:

• Audit codebase (billable, time-consuming)

• Write detailed report

• Quote rebuild: $200k, 6 months

• Client balks at price

Weldr way:

Discovery call: understand current app (2 hours)

Generate equivalent with Weldr (2 hours)

Show client working replacement (next day)

Quote: $20k-$40k to customize + migrate data (vs $200k)

Real example - Healthcare Startup:

• Legacy app: PHP + MySQL, 50k lines, no tests

• Weldr rebuild: Next.js + PostgreSQL, 10k lines (5k generated, 5k custom)

• Migration: 2 weeks vs 6 months quoted

• Client saved $160k

---

Agency Business Models with Weldr

Model 1: Speed-to-Market Agency

Value prop: "Working MVP in 1 week, guaranteed" Pricing:

• Week 1: Generate + deploy ($7.5k flat)

• Week 2-4: Customization ($2k/feature)

• Optional: Training + handoff ($2k)

Margins:

• Week 1: 80% margin (mostly Weldr)

• Week 2-4: 60% margin (your custom code)

Capacity: 4-6 projects/month per developer (vs 1-2 traditional)

---

Model 2: Productized Services

Offer pre-built templates:

Restaurant Booking System - $5k

- Table reservations - Menu management - Order tracking - Customer profiles

Gym Management - $7k

- Class schedules - Member check-ins - Billing/payments - Attendance tracking

Real Estate CRM - $10k

- Property listings - Lead management - Showing scheduler - Document storage Customization: $2k per Extended feature, $5k per Ejected module Process:

Client picks template

You generate with Weldr (1 day)

Customize branding/styling (2 days)

Add custom features as Extended (3-5 days)

Hand off with ownership manifest

Economics:

• 1 week per project

• $5k-$15k revenue

• $3k-$10k profit

• 12-16 projects/quarter per dev

---

Model 3: Maintenance-Free Handoff

Value prop: "No lock-in, no maintenance contracts" How it works:

Generate MVP (Managed mode)

Client signs off

Set up Extended mode ownership manifest

Train client's team (or their future dev)

Hand off with documentation

Client's future:

• They can regenerate with Weldr (schema changes, new features)

• They can add custom code in @custom blocks

• They can eject surfaces when needed

• They never call you unless they want new features

Why clients love it:

• No maintenance hostage situation

• Freedom to hire other devs

• Full source code ownership

• Clear boundaries (Managed vs Extended vs Ejected)

Why you benefit:

• Clean handoffs, no support burden

• Reputation for transparency

• Referrals from happy clients

• Higher-value new projects

---

Agency Team Workflows

Junior Developers

Perfect for:

• Generating MVPs (90% Weldr, 10% customization)

• Extended mode features (add @custom blocks)

• UI customization (styling, branding)

• Client communication (show live preview)

Training time: 1 week to productive (vs 3 months traditional)

---

Senior Developers

Focus on:

• Architecture decisions (which surfaces to eject)

• Complex Ejected modules (pricing, integrations)

• Contract design (define TypeScript interfaces)

• Code review (ensure @custom blocks are clean)

Productivity increase: 5x (no boilerplate, focus on hard problems)

---

Project Managers

Weldr helps with:

• Live previews for client demos

• Real-time feature iteration (chat → instant update)

• Scope management (Managed vs Extended pricing)

• Handoff documentation (ownership manifest)

Client satisfaction: Higher (see working app Week 1, not Week 8)

---

Common Agency Questions

"Will clients know we're using Weldr?"

Your choice: Option 1: Transparent

• "We use Weldr to accelerate development and reduce costs"

• Client benefits: faster delivery, lower price, easier handoff

• Most clients don't care how, just that it works

Option 2: White-label

• Weldr supports white-labeling

• Generated code looks like you wrote it

• Ownership headers can be customized

• Client never knows

Recommendation: Be transparent. Clients appreciate speed + cost savings.

---

"What if client wants full source code?"

That's the point. Progressive Ownership means:

• Client always owns the code

• Full export at any time

• No vendor lock-in (ours or yours)

• Runs anywhere (Vercel, AWS, their servers)

Unlike platforms like Retool or Bubble (platform-locked), Weldr generates real Next.js/React/TypeScript code.

---

"Can we charge the same rates?"

Yes, and justify them: Traditional: $100/hour × 400 hours = $40k (10 weeks) With Weldr:

• Value-based pricing: $40k for delivered app (2 weeks)

• Your time: 80 hours (mostly customization)

• Your rate: $500/hour effective

• Client gets it faster, you earn more per hour

Key: Charge for value delivered, not time spent.

---

"What about our proprietary templates/boilerplate?"

Weldr replaces them. Consider: Your template codebase:

• 50k lines of boilerplate

• Maintained by senior devs

• Updated quarterly

• Forked per client (merge hell)

Weldr:

• Generated fresh per project

• Always up-to-date

• No maintenance burden

• Client-specific from day 1

Transition strategy:

Generate base app with Weldr

Add your custom business logic (Extended/Ejected)

Retire old template

Redirect maintenance time to client work

---

"How do we handle client changes mid-project?"

That's where Progressive Ownership shines: Scenario: Client wants to add a field to database Traditional:

Write migration

Update schema types

Update forms

Update validation

Update API endpoints

Test everything

Bill client for 8 hours

With Weldr:

Chat: "Add 'industry' field to companies"

Weldr regenerates (schema, forms, validation, API)

Custom code in @custom blocks preserved

Bill client for 1 hour (or include in fixed price)

Result: Scope changes become profitable, not painful.

---

Getting Started (Agency Onboarding)

Week 1: Internal Training

Day 1-2: Core concepts

• Progressive Ownership (Managed, Extended, Ejected)

• Ownership manifest

• Extended merge (@weldr and @custom blocks)

• Contract validation

Day 3-4: Hands-on

• Generate 3 sample apps

• Practice Extended mode

• Practice Ejected mode

• Build agency template

Day 5: Process design

• Define productized offerings

• Create pricing model

• Set up white-label (optional)

• Create handoff playbook

---

Week 2: First Client Project (Managed)

Choose a simple project:

• CRUD application (CRM, booking system, directory)

• Managed mode only (no custom code)

• Fixed price: $5k-$7k

• Timeline: 1 week

Goal: Prove speed-to-market, build confidence

---

Week 3-4: Extended Mode Project

Choose a project needing customization:

• E-commerce with custom pricing

• SaaS with integrations

• Marketplace with matching logic

Practice:

• Writing custom code in @custom blocks

• Regenerating with Weldr

• Validating preservation

• Client handoff with Extended mode

---

Month 2+: Ejected Mode & Scale

Advanced techniques:

• Ejecting domain logic for complex projects

• Contract design for Ejected surfaces

• White-label multi-client deployments

• Agency template libraries

---

Agency Pricing Examples

Simple CRUD App (Managed Mode)

Scope: Restaurant management system

• Pricing: $5k fixed

• Time: 1 week (20 hours agency time)

• Margin: $4k profit (80%)

• Delivery: Database, auth, CRUD, admin UI, deploy

---

Custom E-Commerce (Extended Mode)

Scope: Handmade jewelry site with wholesale pricing

• Base MVP: $7.5k (generated)

• Custom wholesale API: $3k (Extended mode)

• Custom email workflows: $2k (Extended mode)

• Brand customization: $2k (Ejected styling)

• Total: $14.5k

• Time: 2 weeks (60 hours agency time)

• Margin: $10k profit (69%)

---

Complex SaaS (Mixed Mode)

Scope: Construction project management with custom workflows

• Base MVP: $10k (generated)

• Custom project scheduling: $8k (Ejected domain logic)

• Integrations (QuickBooks, Procore): $10k (Ejected integrations)

• Mobile-responsive UI: $5k (Extended UI components)

• Total: $33k

• Time: 4 weeks (160 hours agency time)

• Margin: $20k profit (61%)

---

Success Stories

"From 6 Weeks to 6 Days"

DevShop Agency, Austin TX

"We rebuilt our entire productized services model around Weldr:

Before:

• 6 weeks per project

• 2-3 projects per quarter per dev

• $60k revenue/dev/quarter

After:

• 1 week base MVP + 1-2 weeks customization

• 6-8 projects per quarter per dev

• $120k revenue/dev/quarter

We doubled revenue per developer while improving client satisfaction. Clients get working apps in Week 1, not Week 6."

---

"White-Label Booking Systems at Scale"

BookIt Solutions, Remote

"We build booking systems for gyms, salons, restaurants. Before Weldr, each client was a fork nightmare.

Now:

• 1 base template (Weldr generated)

• Custom per client (Extended mode for branding, Ejected for pricing)

• 30 active clients

• 1 shared codebase

• Updates deploy to all clients

• $500/month per client maintenance

• $15k/month recurring revenue

We went from firefighting bugs to actually growing the business."

---

Next Steps

Sign up at weldr.com/agencies

Book agency onboarding (free white-glove setup)

Generate first client MVP (we'll help)

Define productized offerings

Scale to 4-6 projects/month per dev

Agency Program Benefits:

• White-label options

• Volume discounts

• Dedicated support

• Co-marketing opportunities

• Case study support

---

Questions?

• Email: agencies@weldr.com

• Agency Slack: agencies.weldr.com/slack

• Docs: weldr.com/docs/for-agencies

---

"We 10x'd our project capacity without hiring. Weldr handles the boilerplate, we focus on the custom logic that clients actually pay for." - Sarah K., Agency Owner