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

> Clear books. Confident decisions.

- Site: https://waveapps.com
- Category: Accounting & Financial Management
- Platforms: Web app, iOS app, Android app
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 3-4 weeks part-time

## Verdict

Build a personal subset for your own bookkeeping; skip payment gateway integration and bank feeds to save yourself weeks of compliance headaches.

Wave is a full enterprise-grade fintech platform hiding behind a friendly UI, but its core accounting loop—double-entry ledgers, custom invoicing, and basic receipt parsing—can be built as a solid side project by a solo developer using AI tools. The real friction points will not be the UI or database design, but handling double-entry balance validation edge cases without messing up your ledger math, and writing robust OCR extraction logic for messy receipt photos.

### What you can't replicate

- PCI-DSS Level 1 payment gateway underwriting and merchant processing
- Direct institutional bank partnerships via Plaid at production scale
- In-house human bookkeeping and tax advisory services

## What it does

An integrated financial management and accounting software platform tailored for small businesses, freelancers, and solopreneurs.

### Core features

- Double-entry bookkeeping engine with chart of accounts
- Invoice creation, custom branding, and PDF generation
- Bank transaction import and manual categorization
- Receipt scanning with OCR data extraction
- Financial reporting (Profit & Loss, Balance Sheet, Cash Flow)
- Customer and vendor management directory

## The business

### Pricing

- Starter Plan: Free — Just starting your business or looking for the basics?
- Pro Plan: $19/mo — Want to look more polished and save time on admin tasks?

### Funding

$79M raised.
- Series C
- Series D ($24M)
Investors: OMERS Ventures, BDC Venture Fund, NAB Ventures, RBC

Founded 2010.
Team size: 100-300.

## The hard parts

- Maintaining double-entry accounting integrity across all ledger adjustments
- Implementing reliable OCR pipelines to parse arbitrary receipt images into structured fields
- Parsing and normalizing thousands of disparate transaction formats from bank syncs
- Generating compliant financial statements (P&L, Balance Sheet) dynamically from journal lines

## How to vibe code Wave

### Prerequisites

- Node.js (free): Required runtime for running the full-stack Next.js application and toolchain.
- GitHub (free): Version control and deployment pipeline source repository.

### Recommended AI tools

- Claude Code: Best-in-class multi-file agentic coding tool for scaffolding a complex full-stack financial ledger app from scratch.
- Cursor: IDE for reviewing ledger diffs and tweaking UI components for invoices and financial statements.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js Server Actions and API routes
- Database: Turso (SQLite at the edge for relational ledger entries)
- Auth: better-auth
- Payments: None (Personal use)
- Other: OpenAI API (for OCR receipt text extraction), Resend (for sending invoice notification emails)

### Hosting

- Cloudflare (Hosting the Next.js frontend and edge API functions): $0/mo
- Turso (Serverless SQLite database for double-entry bookkeeping ledgers): $0/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Turso SQLite connection via Drizzle ORM, and set up the foundational double-entry accounting schema.

```
Scaffold a new Next.js project with Tailwind CSS, TypeScript, and Drizzle ORM configured for Turso SQLite. Create a robust double-entry bookkeeping database schema. Tables must include: accounts (id, name, type [asset, liability, equity, revenue, expense], normal_balance), transactions (id, date, description, reference), and journal_entries (id, transaction_id, account_id, debit, credit). Ensure constraints enforce that total debits equal total credits for every transaction. Add seed data for a standard chart of accounts.
```

2. **Authentication & User Dashboard** — Implement better-auth for single-user or multi-tenant isolation, and build the main financial dashboard summarizing cash flow, income, and expenses.

```
Integrate better-auth into the Next.js application with email/password credentials. Create a protected dashboard layout with shadcn/ui components. Build server actions and UI widgets that query the database to display real-time financial metrics: total income, total expenses, net profit, and recent transactions mapped from the double-entry journal ledger.
```

3. **Invoicing & Estimate Engine** — Build an invoice creation tool with line items, tax calculations, PDF rendering, and status tracking.

```
Build a comprehensive invoicing and estimates module in Next.js. Create database tables for invoices, invoice_items, customers, and payments. Implement a form interface allowing users to add line items, apply taxes, and save drafts or send invoices. Create a clean printable/PDF view for invoices using react-pdf or Tailwind print styles. Implement invoice status transitions: draft, sent, viewed, paid.
```

4. **Manual Expense Tracking & Receipt OCR** — Implement manual expense logging alongside an OCR upload pipeline using OpenAI Vision to extract vendor names, totals, and line items from uploaded receipt images.

```
Build an expense tracking module with receipt capture. Create an endpoint that accepts uploaded receipt images, stores them securely, and sends them to the OpenAI API (GPT-4o mini) with a structured JSON output prompt to extract vendor name, date, total amount, tax, and line items. Automatically map the extracted data to create a balancing journal entry debiting an expense account and crediting accounts payable or cash.
```

5. **Financial Reports (P&L & Balance Sheet)** — Construct accounting report generators that aggregate journal lines into Profit & Loss and Balance Sheet statements.

```
Build a financial reporting engine that generates real-time Profit & Loss (Income Statement) and Balance Sheet reports from the double-entry journal entries. Create a reporting page with date range pickers (this month, year-to-date, custom) that groups revenue and expense accounts for the P&L, and asset, liability, and equity accounts for the Balance Sheet, ensuring balance sheet identity checks (Assets = Liabilities + Equity).
```

### Cost vs paying

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

- AI coding tool subscription (Claude Code / Cursor): $20
- Total: $20 one-time

**Ongoing costs (monthly):**

- Turso database & Cloudflare hosting: $0
- OpenAI OCR API usage (personal scale): ~$2/mo
- Total: ~$2/mo

- Paying for the SaaS instead: $19/mo
- Build time: 40 hours
- AI tool credits: $20
- Break-even: 1 month

## Sources

- [Wave Official Pricing & Features Directory](https://www.waveapps.com/pricing)
- [Wikipedia: Wave Financial](https://en.wikipedia.org/wiki/Wave_Financial)
- [H&R Block Completes Acquisition of Wave Financial](https://investors.hrblock.com)