One app that runs the whole company, and keeps score

Nothing was broken, which is the dangerous version. Tasks lived in whichever app was open, client details in email signatures, quotes and signed agreements in a downloads folder, and invoices in a spreadsheet that was right as long as one person remembered to update it. Support requests arrived as text messages and were answered from memory. Each piece worked. None of it knew about the rest.

The cost shows up as questions that should be instant and are not. Which agreements renew this month. Which invoice is overdue. Whether the thing a client asked about on Tuesday ever got done. And because nothing was counted, a good week and a bad week felt the same from the inside.

One page at /admin/do with six modules down its sidebar: Tasks, Desk, Nexus, Invoices, Vault and Mail. Each module has its own URL, so a reload, the back button and a pasted link all land where they were, and moving between them is a routed transition rather than a new page. A command menu reaches every task, ticket, client, document and action from one box, and each module's main act sits on a single key.

The page is a React application compiled into one file and committed to the repository, because the server installs nothing by hand: the deploy runs no Node, and a build stamped with a hash of its sources fails verification if the two ever disagree. The server half is plain Python on SQLite, split into modules that run without the web framework, so every rule below is held by a harness that never boots the site.

The gamification is the part people notice first and the part that had to be designed most carefully, because a score that can be gamed is a score nobody trusts. XP is not a column on a task. Finishing a task writes a row in a ledger, and moving the task back out of Done deletes that row. Toggling a card earns nothing. Deleting a finished task keeps what it earned, because the work was done.

Every module writes to the same ledger under its own kinds: winning a client, delivering a project, renewing a service, issuing and collecting an invoice, resolving a ticket, and a requester confirming the fix. A milestone carries a unique reference, so dragging a client back and forth across the pipeline scores once, and stepping back withdraws it. A renewal is never taken back by a stage change: it happened. Only a finished task or a resolved ticket counts as work done, so a milestone can raise the level but never keep a streak alive on its own.

Most work tracking measures presence: hours logged, screens watched, messages answered within minutes. The ledger measures finishes. A task counts when it is done, a ticket when it is resolved, an invoice when it is collected, and nothing about how the day looked in between is recorded, because nothing about it matters to the score. That is what makes the number a positive one to be measured by: it can only go up, and only by finishing something.

The weights say what the company values. A critical finish is worth six times a low one, finishing before the due time pays a bonus, and a ticket pays more when the first reply came inside its target and again when the requester closes it themselves. That last rule is the point of the whole design: the highest-paying thing an agent can do is fix the problem so well that the person who asked says so.

Nothing is ever deducted. A missed due date earns the base and not the bonus; a late ticket still pays its priority. The streak is the one thing that can lapse, and it survives until midnight on the business clock, so a quiet morning does not break it. The daily goal is the person's own, picked from a short list, and the sounds and the confetti switch off with one key. Every rule is a few lines of code and the ledger is a table anyone can read, so a number is never a mystery and never an argument.

Six modules, each described beside its own screen. Every name, figure and file in these pictures is placeholder data from a throwaway database, seeded to show the system working: nothing here is a client of ours.

Tasks

A board, a table and a calendar over one filtered list, with five domains that each add their own fields to a card. An email becomes a task once and only once, keyed on its thread. Calendar sync needs no OAuth: the Google link opens Calendar's own add-event screen prefilled, and every .ics keeps a stable identifier per task so importing again updates instead of duplicating. The command menu reaches every task, ticket, client, document and action from one box.

Nexus, the client book

Clients at the top, the projects built for them and the services they pay for underneath, every one linkable to tasks and documents. Badges tell clients apart at a glance, a client has any number of contacts with exactly one primary, and a new task fills its contact block from the client picked. Late is never stored: it is read from the dates every time a row is shown, so nothing has to run at midnight for a ring to turn red, and renewing clears it the moment it saves.

Vault, the documents

Quotes, contracts, invoices and assets, stored once under the hash of their bytes. Only bytes that prove what they are may open in the browser; everything else is a download, whatever its name says. A share link expires in one, seven or thirty days, only its hash is stored, and the public page it opens carries no analytics tag, because the secret is in the address. A presentation viewer draws PDFs and images itself and hands Word and PowerPoint files to Microsoft's viewer through a short-lived ticket, never a share token.

Desk, the help desk

An incident desk with the bones of the big ones: a priority read off a three-by-three impact and urgency matrix, response and fix targets measured in business hours, one state machine, routing by category to the least-loaded agent, public replies beside private notes, and an audit trail. Clients sign up to the portal only with a company code or an invite link the Nexus issued, and resolving a ticket scores the same ledger as finishing a task.

Invoices

From draft to issued to paid. Issuing one assigns its number, freezes the theme and bank details, renders a PDF with nothing but the standard library, files it in the Vault under the client, and scores the ledger. The client's pay page is its own shell, offers a card link when the processor is set up and bank details otherwise, and a payment can land by hand, by webhook, or by reconciling the bank feed.

Mail

Every linked mailbox in one inbox with a composer and a template library that fills itself from the client book. Provider traffic never runs in a web request; a separate worker does it, holding a lock so one sync runs per shard. Credentials are sealed under the server's own key, every message is sanitised before it reaches the screen and framed without scripts, and pictures travel through a proxy that checks each hop, so a tracking pixel reports nothing.

The practical return is that the questions are instant now. The Nexus's attention tab lists every renewal inside thirty days and every project past its date, most urgent first. The invoices strip says what is awaiting payment and what is overdue. The desk says what is past a target. The board says what is due today. None of it is a report somebody runs; it is the state of the tables, drawn.

The second return is the one the scoreboard was built for. A day with a number on it gets compared to yesterday, a streak gets protected, and a client whose level has not moved in a month is a client about to be forgotten. The sound effects and the confetti are optional, and the ledger underneath them is not.

Today the board has one sign-in, and the help desk has named agents with a leaderboard: resolved in the last thirty days, on-time rate, open now. That is the shape a team version grows from. Each person gets a ledger of their own, team velocity is the sum of them, a client's level is still earned by whoever did the work, and a manager's view is a list of what got finished this week rather than who looked busy. The rules do not change with the headcount: rows not columns, one reference per milestone, nothing deducted, every rule readable.

We are building toward offering it hosted. A company signs up, invites its people and its clients, and gets the board, the desk, the client book, the vault, invoicing and mail with the scoring already in place. Multi-tenant storage, per-person sign-ins and roles are the work in front of us; the scoring, the help desk, the share links and the pay page are built and in daily use. If you would like to run your team on it early, the form at the foot of this page reaches the people building it.

We run on it. The task board replaced the to-do app, the client book replaced the signatures and the spreadsheet, the Vault replaced the downloads folder, invoices go out of the same page that tracks the work, and support requests arrive as tickets with a target instead of as texts. The owner's own setup work lands on the same board: when a change ships that needs a key pasted or a console setting flipped, the deploy files it as a task, once, with the steps as a checklist.

The honest measure is that the system is used on the days when nothing is wrong, which is the test most internal tools fail. It is also a working example of how we build: server-rendered where it can be, one bundle where it cannot, stdlib-only modules with a harness each, and a deploy that needs nobody at a keyboard. The same approach is what a client gets.