🦊 FoxyInvoice

Building FoxyInvoice — a complete series

A real, live invoicing SaaS, documented end to end: architecture, security, tax domain, hosting, CI/CD, unit economics, and the operating cadence — written while building it, for developers who want to ship their own product.

00

Introduction: we built an invoicing SaaS, and you can too

This is the story of FoxyInvoice — a real, live, multi-tenant invoicing SaaS — and a complete, step-by-step guide to building, hosting, securing, operating, and growing one yoursel

01

Prerequisites: every term you need, and where it will bite you

This chapter is a map, not a textbook. Every term below gets the same treatment: what it is in plain words, where it lives in FoxyInvoice, and — because this series made an honesty

02

Product thinking: pick a real problem, price it, position it

Here is the uncomfortable statistic that shapes this chapter: most software built by developers fails not because the code was bad, but because it was the wrong thing to build. The

03

Architecture: one codebase, two products, boring on purpose

Every architecture decision in this system answers one question: can one tired person run this at 2 a.m.? Not "could it scale to a million users" (it can, further than you'd think)

04

Multi-tenancy & data security: the vault

Multi-tenant means many unrelated companies share one running system and one database, each seeing only its own data. Get it right and hosting stays cheap forever. Get it wrong and

05

The domain: invoices, tax, and money math

The "domain" is the part of the software that would be true even if you ran the business on paper: what an invoice is, when tax applies, how a quote becomes a bill. Get this layer

06

Accounts, hosting, DNS, email: from zero to a domain

This is the chapter people skip and then suffer: the accounts, the names, the records that turn code on your laptop into a URL someone else can type. It's step-by-step because orde

07

CI/CD: push to `main` and it's live

There is no staging environment in this system. There is main, and main is production. That sounds reckless until you see the gates — and the alternative for a solo operator (a sta

08

Unit economics: what it actually costs

This is the chapter most build-in-public series skip, which is exactly why it's here. The numbers below are the real cost structure of running FoxyInvoice at its current scale, wit

09

The daily cadence: twenty minutes that run the business

Products don't fail from missing features; they fail from absent operators. The antidote isn't more hours — it's a cadence: a small, fixed routine you can keep on your worst day. O

10

Feedback → tickets → shipped: closing the loop while they remember

The single most valuable object in this company is a bug report from a real user. It is worth more than a roadmap session (it's evidence, not opinion) and more than an analytics da

11

Reach: SEO, AI crawlers, and being the machine-readable answer

Somewhere between "launched" and "learned people exist," every product discovers distribution. Ours arrived with a twist that defines this chapter: half your future traffic now arr

12

Engagement & automation: UI first, then automate

"Engagement" conjures dark-pattern streaks and notification spam. It shouldn't. Engagement is the product working so well that leaving it half-finished feels like loss — progress t

13

War stories: six postmortems and what each one cost

Every incident below is real, timestamped in git, and shipped a permanent change to how we work. The format is the same each time — symptom, diagnosis, fix, lesson — because the le

A

Appendix A — Glossary, checklists, and the video storyboard

Git & process - Repository (repo) — the project plus its full history. - Commit — one versioned snapshot with a message. - Branch / merge / rebase — parallel lines of work / combin