# How to Vibe Code Your Own Paddle (and Stop Paying for It)

> Merchant of Record platform purpose-built for SaaS and apps

- Site: https://paddle.com
- Category: Payments & Merchant of Record
- Verdict: **Don't bother** (12/100 vibecodeable)
- Estimated effort: impossible (legal reality)

## Verdict

Building a personal Merchant of Record clone is a non-starter because the barrier is not software code—it is legal liability across 300+ global tax jurisdictions. Keep paying the 5% + 50¢ MoR fee.

You can spin up a Stripe API wrapper with a database in a weekend, but that makes you a Payment Service Provider, not a Merchant of Record. To actually clone Paddle, you would need to legally incorporate local entities worldwide, acquire tax registration bonds in every US state and EU country, and expose your personal assets to foreign tax audits. An AI coding agent can build a slick Next.js dashboard and checkout drawer, but it cannot write code that legally absolves you of global VAT remittance liability.

### What you can't replicate

- Legal Merchant of Record reseller status and indemnification
- Global tax registration bonds and direct filing relationships with foreign tax authorities
- Absorbing fraudulent chargeback liabilities out of your own balance sheet

## What it does

Paddle acts as the principal reseller of your software, completely abstracting away global tax compliance, multi-currency localization, fraud protection, and subscription billing.

### Core features

- Merchant of Record checkout overlay & inline embedding
- Global tax nexus calculation & automated tax remittance
- Multi-currency localized pricing matrices
- Subscription lifecycle management & proration engine
- Automated dunning & card failure recovery engine
- Fraud screening and chargeback liability management
- Developer REST APIs & real-time webhook delivery pipeline
- ProfitWell-style subscription analytics dashboard

## The business

### Pricing

- Pay-as-you-go: 5% + 50¢ — Per successful checkout transaction with zero monthly fees
- Custom Enterprise: Custom — Tailored volume-based pricing for scaling businesses

### Funding

$318M raised.
- Series A ($3.2M, Sept 2016)
- Series B (Dec 2017)
- Series C ($68M, Nov 2020)
- Series D ($200M, May 2022)
- Debt Financing ($25M, July 2025)
Investors: KKR, FTV Capital, 83North, Notion Capital, Kindred Capital, BGF, CIBC Innovation Banking

Founded 2012.
Team size: 300+.

## The hard parts

- Legal entity structuring and assuming global tax audit liabilities
- Real-time tax calculation database covering 300+ jurisdictions and product classifications
- Multi-acquirer payment routing failover to ensure high global acceptance rates
- PCI-DSS scope handling for secure card data tokenization and routing

## How to vibe code Paddle

### Prerequisites

- Node.js (free): Runtime environment for building the dashboard and API services
- GitHub (free): Repository hosting and version control for your codebase
- Stripe Account (free): Underlying payment processor sandbox to simulate raw card rails

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding a complete multi-model subscription billing dashboard from terminal prompts
- Cursor: AI-native editor for rapidly fine-tuning checkout widget components and embedded iframe code

### Stack

- Frontend: Next.js
- Backend: Next.js API Routes
- Database: Neon
- Auth: better-auth
- Payments: Stripe
- Other: Tailwind CSS, Resend, PostHog

### Hosting

- Vercel (Hosting the Next.js billing dashboard, mock checkout widgets, and webhook dispatchers): $0-20/mo
- Neon (Serverless Postgres database storing products, subscriptions, customers, and mock tax logs): $0/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js application with Tailwind CSS, configure Neon Postgres with Drizzle ORM, and set up the relational schema for merchants, products, prices, subscriptions, and transactions.

```
Scramble up a new Next.js project using App Router and Tailwind CSS. Configure Drizzle ORM to connect to a Neon Postgres database. Define a robust schema with tables for tenants (merchants), products, subscription prices, customers, subscriptions, and webhook_events. Include proper foreign keys, timestamps, and indexes for lookup performance. Ensure TypeScript strict mode is enabled throughout.
```

2. **Authentication & Merchant Dashboard** — Implement authentication using better-auth and build a multi-tenant dashboard allowing merchants to create products, set recurring billing intervals, and view revenue analytics.

```
Integrate better-auth for merchant user authentication supporting email/password and secure session management. Build a merchant dashboard interface with Tailwind CSS containing views for creating products, defining flat or recurring subscription prices, viewing active subscriber counts, and managing webhook endpoints. Create server actions to handle CRUD operations on products and pricing models securely.
```

3. **Embeddable Checkout Widget & Mock MoR Engine** — Build an embeddable client-side JavaScript snippet and overlay checkout modal that simulates Paddle's hosted checkout experience, calculating mock sales tax based on buyer country headers.

```
Develop an embeddable client-side JavaScript SDK and overlay checkout modal component that mimics Paddle Checkout. The checkout UI should collect customer billing details, simulate local currency formatting, calculate a mock regional sales tax rate based on the buyer's IP or country selection, and process payment securely via Stripe Elements in test mode. Upon successful payment, record the transaction in the database and trigger an internal MoR reseller record.
```

4. **Subscription Lifecycle & Dunning Simulator** — Implement subscription state machines handling renewals, trial periods, upgrades/downgrades, and automated dunning retry logic for failed payments.

```
Build a subscription lifecycle management engine supporting active, trialing, past_due, and canceled states. Add backend cron jobs or scheduled API endpoints to handle recurring billing renewals, mid-cycle prorations for plan upgrades or downgrades, and an automated dunning simulator that flags failed charges and schedules retry notification emails via Resend.
```

5. **Webhook Dispatcher & Developer API** — Create a secure webhook dispatching pipeline that notifies merchant endpoints of billing events (subscription created, payment succeeded, payment failed) with HMAC signature verification.

```
Implement a robust webhook delivery system in Next.js that listens for internal billing events and dispatches HTTP POST payloads to registered merchant endpoints. Include automatic retry backoff logic for failed webhook deliveries, event log tracking in the database, and HMAC-SHA256 signature headers for payload verification so merchants can authenticate incoming notifications securely.
```

### Cost vs paying

**Starting costs (one-time):**

- Domain name: $12 one-time
- AI coding credits: $20 one-time
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby/Pro: $0-20/mo
- Neon Postgres: $0/mo
- Resend transactional email: $0/mo
- Total: ~$0-20/mo

- Paying for the SaaS instead: 5% + 50¢ per transaction (MoR)
- Build time: 80-120 hours (Subset billing app, excluding legal MoR liabilities)
- AI tool credits: $20 one-time (Claude Pro)
- Break-even: Infinite (You cannot clone Merchant of Record legal protection as a side project)

## Sources

- [Paddle Official Website](https://www.paddle.com)
- [Paddle Pricing Page](https://www.paddle.com/pricing)
- [Paddle About Us Page](https://www.paddle.com/about)