Skip to content
Context
Personal product
Type
SaaS in production
Role
Founder & Software Engineer
Period
2026 — ongoing
Stack
Docker, Laravel, PHP, PostgreSQL, Tailwind CSS, TypeScript, Vue.js

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.

FACTio home page
Fig. 1 — FACTio home page

At a glance

Key decisions.

  1. 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.

  2. 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.

  3. 03Accounting you don't rewrite

    Automatic OHADA entries, corrections by reversal, a year-end closing that locks the period, FEC export, balance tests.

  4. 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.

  5. 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 FACTio architecture: Vue application, two nginx instances, Laravel API, queue worker, scheduler, PostgreSQL and external services

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.