FACTio
My own SaaS for invoicing and payment tracking, aimed at freelancers and small businesses.
Small businesses can’t afford an accountant day to day. Invoices are issued as they go, scattered, with whatever knowledge is at hand. And at year end, when financial statements have to go to the State, everyone is overwhelmed.
FACTio started from that observation. I built it to issue invoices and quotes, track expenses and give a view of the books without the user having to enter anything. With the arrival of the FNE in Côte d’Ivoire, it also simplifies an integration that is difficult.
It is my own SaaS, from the first commit in January 2026 to automated deployment in production. This case study covers the decisions that shaped its architecture, what I chose to postpone, and what is still to do.

At a glance
Key decisions.
01WhatsApp: from embedded to a dedicated service
Problem: an engine inside the repository ties the product to an unstable component. Decision: FACTio becomes a client of Wasly, my other SaaS (WhatsApp), with one session per company and HMAC-SHA256 signed webhooks. Consequence: messaging becomes a service of its own, which FACTio uses like any other customer.
02Numbering without duplicates
One counter per company, type and year, incremented under
SELECT … FOR UPDATE. A taken number is skipped, never reused; format (prefix, separator, padding) is configurable.03Accounting you don't rewrite
Automatic OHADA entries, corrections by reversal, a year-end closing that locks the period, FEC export, balance tests.
04FNE: one link per company, with guardrails
Each company enters its production URL, validated before any call; the same certification cannot run twice in parallel.
05Deploy without breaking things
Production deployment only runs after green CI on the main branch, without downtime, on up-to-date base images.
Where it started
I wanted to answer that observation with a simple tool: you issue your invoices and quotes, you track your expenses, and all of it gives a view of the books without the user having to enter anything. The intended effect is twofold. Entrepreneurs pick up accounting notions by seeing what their own day-to-day operations produce; and since everything is centralised, the accountant can build a high-quality financial statement at year end, with confidence.
A second trigger was the arrival of the FNE in Côte d’Ivoire. Integrating it into a system is difficult; FACTio simplifies it, and it is my way of encouraging companies to stay compliant.
I don’t publish adoption numbers here: they are not the point of this case study.
The first building blocks
The repository was created on 3 January 2026 with a Laravel API and a Vue app in a single monorepo. In the first days I wrote the authentication screens and the deployment configuration. Then the project went quiet until late March.
In March the real problem became going live. For a week the commits read like any first deployment: ports, nginx, environment variables, CORS, timeouts. In the end, a GitHub Actions pipeline deployed to a VPS. April brought subscriptions, permissions, support channels and error tracking with Sentry. In September I added the affiliate programme and my first complete test suite with CI.
A deliberately simple architecture
The backend is a Laravel API authenticated with Sanctum, with three separate spaces: user, admin and affiliate. The frontend is a Vue application in TypeScript (Vite, Pinia, Tailwind) that can be installed as a web app.
In production, Docker Compose runs five services: the API on php-fpm, a queue worker for outgoing messages, a scheduler for recurring tasks, and two nginx instances. Data lives in PostgreSQL; tests run on SQLite. External services are few: Lemon Squeezy for subscriptions, the FNE platform for certification, Google for sign-in, Sentry for errors, and Wasly, the WhatsApp messaging SaaS I am building in parallel, with FACTio as its first customer.
Simplified diagram, based on the project’s Docker Compose configuration.
I did not try to build a « scalable » architecture before having users: one monorepo, one database, clearly separated services.
October: from a product to a roadmap
In October 2026 I changed how I worked. I wrote a roadmap from the actual state of the code (routes, models, migrations, services) and then executed it in batches: foundations, audit log, PDF, invoicing, customers, reminders, expenses and cash management, accounting, authentication and subscription, observability, customer portal and PWA. Each batch was merged before the next one.
I got help from a coding assistant (Claude): to debug certain errors, to challenge my proposals against my original ideas and to implement several batches. The scope, the trade-offs and the validation (tests, CI, production release) stayed mine.
On 6 October a set of decisions fixed the direction: card subscription with automatic billing (no Mobile Money), uncapped WhatsApp outside the trial to attract the first users, and online payment by the end customer postponed.
The decisions that shaped the product
WhatsApp: separating the engine from the product. The first version embedded a WhatsApp engine in the repository. I moved it out of FACTio to rely on Wasly, the other SaaS I am building and for which FACTio is the first customer: one session per company, queued sending, signed webhooks. Each product keeps its own responsibilities.
Numbering: a locked counter. An invoice must carry a unique number even when two users create a document at the same instant. Each company has one series per document type and per year, incremented inside a locked transaction. A number already taken is skipped, never reused. The format is configurable.
Accounting: we never rewrite history. OHADA entries are generated automatically, corrections go through reversing entries, and closing a fiscal year locks the period. Tests check that entries balance. One bug reminded me why: third-party accounts shared between customers had to be repaired with a dedicated command.
FNE: each company keeps its own link. I decided that each company enters its own FNE production link. That choice needed guardrails: the address is validated before any call, and the same certification cannot run twice in parallel. The PDF carries the DGI sticker with its number and QR code.
Deployment: never without green CI. Production deployment only runs when CI is green on the main branch, without stopping containers, and pulls fresh base images.
Quality, and its pitfalls
CI runs linting, dependency audits, backend tests, frontend tests, the build and an end-to-end Playwright journey against a production build. It also taught me concrete lessons: an intermittent failure caused by OPcache’s JIT on the runners, an unstable E2E journey fixed by switching SQLite to WAL mode, security advisories with no available fix that I documented instead of breaking the lint setup.
Reviewing the code also surfaced several security flaws, which I fixed.
What I left out
No Mobile Money subscription, no online payment for the end customer, no bank reconciliation, no stock management, no multi-currency. These absences are decisions or deferrals, not oversights. FACTio ships no artificial-intelligence feature: AI helped build the product, it does not run it.
Where FACTio stands
The product is in production, deployed automatically after every green CI run. The latest versioned work covers dependency and base-image security. Around the code, the project comes with a landing page, a demo playbook and presentation videos.
Still to do: quote reminders, history import, bank reconciliation and, depending on adoption, online payment by the end customer.