lotus, the app that runs my one-person business

In October 2026, I left my position as front-end lead to become a freelance front-end engineer, as a French micro-entrepreneur, just as I was leaving for a year in Latin America. I needed a single place to know where I stand, usable from a computer as well as from a phone, with a network or barely any.

What I wanted to keep track of: the revenue collected and what is left under the ceilings, the contributions to set aside, the URSSAF (French social security) and tax deadlines reminded in my calendar, clean invoices made from what I actually delivered, the leads that came through the form on my site, regular contact with my clients, and my documents in one place.

Four principles

• +
  Compute rather than type.

  The revenue ledger comes from payments, contributions from the ledger, deadlines from my status, tasks from rules.

• +
  Suggest, do not decide.

  Reminders, amounts to declare, suggestions to clients: the app prepares, I approve.

• +
  The exact figure, the rule in sight.

  Every computed amount shows its base and its rate.

• +
  Restraint.

  My visual identity, without exception: one font, one accent, no red. An alert is written in bold.

Seven screens, a sidebar that becomes a drawer on a phone, a day mode and a night mode.

dashboard

Revenue collected, what is still to collect, what to set aside for URSSAF, the current tasks, the latest leads.

accounting

Revenue ledger, micro-enterprise ceiling, VAT exemption, contributions detailed line by line, CSV and PDF exports, yearly archive.

deadlines

Calendar of the month, upcoming declarations, tasks, sync with Google Calendar.

clients

Client record, services to invoice, maintenance subscriptions, email history, suggestions of the month.

invoices

Generator based on services, a preview faithful to the PDF, sending, payments, reminders, credit notes and quotes.

leads

Requests from the form on my site, in a pipeline, up to conversion into a client.

documents

Presentations, proposals, audits, contracts and generated PDFs, filed and shareable through a link that expires.

The “compute rather than type” principle shapes the whole app. There is almost only one thing I type by hand: the date and the amount of a payment received. Everything else follows from it.

An invoice is a legal document: a number that follows on without gaps, mandatory mentions, amounts that no longer move once sent. It is the part where a mistake costs the most, and the one where the code is the strictest.

The most important working rule of the project fits on one line: never guess a tax rule. Rates and thresholds live in a single file, each with its validity date, and are tested. A year that is not covered reuses the latest known version and says so: “2026 rate · to be confirmed for 2027”.

Never guess a tax rule.

Every night, a cron generates the obligations of the next fifteen months from my settings: quarterly URSSAF declarations, income tax, CFE (the French business property tax). The estimated amount of a declaration is computed again from the revenue ledger as long as it has not been filed. An obligation once declared no longer moves.

These deadlines, the due dates of invoices and my dated tasks go to a “lotus” calendar in my Google Calendar, with the narrowest possible scope: the app only sees the calendar it created. A token-based ICS feed, which can be regenerated, does the same for any other calendar.

On the ceilings side, the invoice generator shows the effect of the amount before I issue it: share of the micro-enterprise ceiling, and an alert if the invoice would push revenue over the VAT exemption threshold.

The contact form of my site and lotus are two separate applications. The contract between them is written once, in a document that is authoritative for both repositories. The starting rule: a lead is never lost because lotus is unavailable.

Bank details, revenue, lead data: an app for a single person, but exposed to the world.

• +
  A public surface that is listed, in full.

  Sign-in, legal pages, signed webhook, crons behind a secret, token-based ICS feed, share links. Everything else requires a session checked on the server, and a test checks it module by module.

• +
  Share links that give nothing away.

  A 32-byte token of which only the hash is stored; expired, revoked or unknown, the answer is the same: “This link has expired.”

• +
  Invisible to search engines.

  Strict headers on every route, and nothing indexable.

• +
  One backup a month. Two years kept, on top of Neon’s point-in-time restore.

One trade-off is accepted and written down: the content security policy does not use a nonce, because a nonce forces dynamic rendering of every page and breaks the partial prerendering of Next.js 16. The rest of the policy is strict.

lotus is the first project I ran this way, just before pensee. A complete specification first: vision, architecture, data model, business rules of the micro-enterprise, the visual identity applied to shadcn/ui, twelve features with their acceptance criteria, a Drizzle schema and reference tax rules, and the screen mock-ups. Then development, phase by phase.

Each phase ends with a build, a lint and green tests, and a commit. Two files hold the project’s memory: the progress status, to pick up again after a break, and a decision log, where every gap from the spec is recorded with its reason. It holds forty-seven of them.

• +
  A tax rule is not guessed.

  It is dated, tested, and stays editable when it is uncertain.

• +
  Computing rather than typing removes a whole class of errors: copying errors.
• +
  A decision log is worth a code review.

  Forty-seven gaps explained is what makes it possible to revisit a choice months later without redoing it.

• +
  Two apps that talk through a written contract.

  The site and lotus each evolve on their own, without ever breaking each other.