What Is Here

One file, about seven and a half megabytes, holding the entire product.

You drop a spend export onto it and it builds the dashboards, the forecast, the close and the reporting sheets. There is nothing to install and nothing is uploaded: what you load stays in the browser tab.

Data Warehouse, Analytics, PPV Forecasting, Reporting, Close and Load.

Those five are the product: look at the rows, look at the picture, build the forecast, produce the sheets that get sent, and lock a month so its numbers can never move again.

The last two releases, kept exactly as they shipped.

If something in the current one looks wrong you can open last month's and see what it used to do. They are never edited again, which is the whole reason they are worth keeping.

The older releases and the design prototypes that came before them.

It is the record of how the product got here, which is what you reach for when somebody asks why something works the way it does.

Four database files holding the spend history, already cleaned and indexed.

It is the difference between hunting through a folder of spreadsheets and asking a question. Anything that needs to look across weeks, periods or regions reads these instead of parsing an export again.

The scripts that read a raw export and write the tables.

It means the warehouse can always be rebuilt from the source. Nothing in it was typed by hand, so nothing in it can quietly go stale.

The spend export the whole thing runs on, and the code that understands it.

A raw pull out of the reporting system is missing six of the columns the close needs. This derives them instead of asking anyone to add them by hand, so a raw pull and a hand made file end up with the same columns and can be loaded together.

A synthetic spend file with the same shape as the real one and none of the real numbers.

It is what you demo with. Every screen fills, nothing on it belongs to anybody, and it is safe to hand to a person or leave sitting on a public address.

Saved questions, written in SQL, that pull from the source systems.

Each one is a question somebody already worked out how to ask correctly. Writing them down means nobody has to work it out a second time.

Taking a month's spend, explaining what moved, and locking it.

This is the month end job. Once a month is locked, its numbers can never move again, which is what makes a number you reported last month still the same number this month.

For every line over a threshold, the reason it changed, worked out rather than guessed.

It is the part of the close that used to be a day of asking people. Three months are explained this way already, line by line.

The week's purchase price variance, rebuilt from the source every time.

It replaces a hand built spreadsheet that took most of a morning. It produces the team's own layout, with every figure a formula you can click rather than a pasted number.

The same weekly engine, run against weeks that already happened.

If the engine would have got a past week wrong, that is a Monday morning failure waiting to happen. Running history through it finds those before they cost anything.

The same work for the other region, whose data arrives in a different shape.

It means this is not one region's tool. The check workbook puts the app's figures beside the raw export's own rows so the region can see them agree.

A run rate forecast off the actuals, with the categories that must be entered by hand left alone.

Four categories must never be forecast automatically, by instruction. The App enforces that in one place rather than trusting anyone to remember it.

A real web address, with a sign in wall, and the door page you land on behind it.

It is the difference between a file on one laptop and something you send a person a link to. It asks for an email, sends a one time code, lets in only the addresses on the list, and then opens on one page that everything else opens from.

A small program on this Mac that answers questions about the warehouse.

A page can ask it for rows instead of somebody dragging a file in. The real figures never leave the Mac: the page comes from the internet, the figures come from here.

The same tables, opened so an assistant can query them directly while you talk to it.

It means a question asked in words gets answered off the real tables instead of off a guess.

A panel in The App that talks to the local service.

It is the first place the two halves meet: the product on the address, the figures on this Mac.

One command that refuses if the app file is broken.

Nothing ships past it. It checks the file's structure, that the version is stamped exactly once, and that every piece of code inside it actually parses.

It photographs every screen in both colour themes and compares them against approved pictures.

A styling change that quietly breaks a screen three clicks away is the commonest way a file like this goes wrong. This catches it in about a minute.

It puts each approved design beside the live screen and counts what does not match.

A design that was drawn and then drifted is invisible until somebody measures it. This measures it, one claim at a time.

A figure cannot be reported unless an independent check on it is attached and passing.

Seven wrong results in one night were all the same shape: the figure was produced and the evidence that it could be measured at all was not. This refuses to report one.

A search that finds nothing has to print what it looked at and what it skipped.

Twice a search returned a clean result that was wrong because of its own filter, and the output looked exactly like a real answer. Now it cannot.

It reads every file about to leave this machine and refuses if a real figure is in it.

It is what makes hosting anything safe at all. It compares against the real figures themselves, so relabelling a file does not get it past.

Deliberate faults planted into throwaway copies, to prove each guard actually refuses.

A check that has never been shown to fail is a claim, not a check. This is what turns the claims into checks.

Four numbers printed at the start of every session: data exposed, guard active, coverage, claims verified.

It is the answer to whether the state you inherited was ever actually checked. It runs itself, so it cannot be quietly skipped.

Eight rules every page built here has to pass before it is sent to anybody.

It is why the pages look like one product. It catches a colour typed in by hand, a dash he has banned, text in a shade too dark to read, and a page that would render wrong in the other theme.

The map and tutorial for the people who will use The App.

It is what you send somebody instead of sitting next to them. It is written plainly enough to send to people who will never open the thing.

One page of rules every screen here is built against.

It is why eleven surfaces look like one product rather than eleven. It names the colours, the type, and what a table has to do before it counts as finished.

Excel files putting our figure and the source figure side by side, with the formula showing.

It is how a number gets believed by somebody who was not there. Every figure is a formula you can click, not a value somebody pasted.

A folder for each thing sent out: the files, the message, and what was checked before it went.

It makes a send repeatable, and gives a question three weeks later an answer. Each kit lists what was verified and what was not.

A short film of the product being used, with the fundamentals taught from nothing.

It is the version for somebody who will not read anything at all.

Jobs this Mac starts on its own, whether or not anyone is at the keyboard.

They have been running unattended and he has never seen them. That is the point of putting them on a page: a job you cannot see is a job you cannot trust.

One command that prints where everything stands.

It is what gets read before anything is touched, so nobody starts work on a stale picture.

One list, every row dated, of everything open and who it is waiting on.

Open items used to live in five places and not one of them carried a date, so a month old ask read exactly like this morning's. Now they are aged automatically and an item cannot vanish without a reason written beside it.

One file per piece of work, written while it happens rather than afterwards.

It is the only record of work in flight. Everything else is a view of it.

A brief written for the next session, because the next session remembers nothing.

It is how work survives the end of a conversation. Every lane running tonight started as one of these.

Every session written down word for word.

A routine he had used for months left no trace anywhere and survived only because he still remembered it. Now a session with no transcript is named at the start of the next one.

The standing rules, and a script counting how many of them are backed by something that refuses.

A rulebook that is mostly decoration is worse than none, because the look of a governed system kills the suspicion that would have caught the next failure. This counts the decoration.

The read me and the working rules file at the top of the tree.

They are what a new person, or a new session, reads first.