The stack we actually use

People who ask about our "AI stack" are usually braced for a logo parade — the slide with thirty software badges arranged like a NASCAR hood. I'm going to disappoint them here, in writing, on purpose. The honest answer is that we chose our tools the way you choose subcontractors: nobody gets hired for the truck wrap. Two questions decide everything. What does it cost to run? And who's in control when it breaks?

Those two questions produced a stack that is cheaper and more boring than anyone expects, and I've come to believe the boring is load-bearing.

Where the truth lives

Chapter 1.2 — One source of truth per domain made the case that every domain needs one owning system. Here's who got each job.

Money: ERPNext. An open-source ERP — open-source meaning the software's code is free and public, and you run it yourself rather than renting it. Ours runs in Docker, which is a way of running server software in a tidy, self-contained box on your own machine. It holds the general ledger, and every property gets its own cost center, so every dollar flows to a specific project. The entire accounting build — software, configuration, the AI bookkeeping on top — came to about $5,000. The name-brand construction ERPs quote numbers with more commas. That story gets its own chapter (2.7 — Enterprise accounting for $5K).

People: a CRM on Firebase. Firebase is Google's platform for hosting small applications. Our contact database lives there, syncs with Gmail, and flags who needs a follow-up.

Time: Google Calendar. No customization, no cleverness. The schedule of record is the calendar everyone already knows how to use.

Plans: an Obsidian vault. A folder of plain-text notes — strategy, decisions, procedures, project docs. Plain text is a deliberate choice, not a budget one: it's the only file format guaranteed to outlive every vendor, every app, and every pivot in this entire stack.

Who does the thinking

On top of the truth layer sits the intelligence layer — the part people actually mean when they say AI.

Claude Code is the primary tool. It's an AI assistant that lives in the terminal — the black window with the blinking cursor — and unlike a chatbot, it can read files, write code, run programs, and query our systems. Nearly everything in this book was built with it, which is a strange sentence to type: the AI is both a worker in the system and the crew that built the system. However, it is also worth knowing that we can swap and interchange Codex, Gemini or Grok or an open model at anytime because of how our setup is engineered. More to follow on this.

The daemon is the always-on part. A daemon — an old programmer's word for a small program that runs continuously in the background — carries our 21 (and counting) scheduled jobs: the morning brief, meeting prep the night before, data syncs, health checks, the overnight batch. Most run as cron jobs, tasks that fire on a schedule whether anyone remembers them or not. This is the piece that makes the system feel like staff instead of a tool; it works whether or not I show up.

A local model handles the private stuff. We run a model through Ollama — free software for running AI models entirely on your own computer. Actual financial figures, deal terms, and contact details go only there, never to any cloud AI. The cloud model sees how — the frameworks, the code, the patterns. The local model sees what — the real numbers. That split is a governance decision, not a technical one, and it gets the full treatment in Chapter 1.4 — Governance before capability.

Memory makes it compound. Around 500 plain-text memory files hold corrections, lessons, and preferences the system consults before acting — so a mistake corrected in March stays corrected in September. Chapter 2.4 — Giving the system a memory covers how, including why the system is designed to forget.

The spine and the boring parts

Underneath everything, Google Workspace is the spine: mail, calendar, and Google Chat, which is where the system's notifications land. When the morning brief arrives, it arrives as an ordinary chat message on my phone — no new app for anyone to learn, no dashboard for anyone to forget to open. We learned the dashboard lesson expensively; it's Chapter 2.12 — The dashboard we killed.

The rest is deliberately dull. PostgreSQL — a heavy-duty free database — holds the market data. SQLite — a database that lives in a single file — handles the small stuff. Forty-odd small Python scripts do the repetitive work: syncing tasks, matching bank transactions, generating reports. A script is just operational knowledge written down so precisely a machine can execute it, which makes the scripts folder the most honest procedures manual we own.

If you want every last component, that's Appendix A — The full stack list. The point of this chapter isn't the inventory. It's the selection logic.

Why cost and control beat logos

Every choice above traces back to the same two questions, so let me make the logic explicit.

Cost, because AI compounds whatever sits under it. If your foundation systems charge per seat, per module, and per API call, every automation you add multiplies the meter. Open-source foundations mean the marginal cost of asking the system to do more is close to zero, which is precisely what lets a small company automate like a large one. The $5,000 accounting system isn't impressive because it was cheap. It's impressive because everything bolted onto it since has been nearly free.

Control, because our privacy rules require it. The cloud-sees-how, local-sees-what split is only possible on a stack we actually control. A system you can't self-host can't honor that rule, at any price. Control also means that when something breaks — and Part III of this book is an extended confession about things breaking — we can open the hood ourselves instead of filing a support ticket into the void.

Note what this isn't: it isn't anti-cloud. Google Workspace is cloud. Firebase is cloud. The rule is to choose control where control matters — money and private data — and choose convenience everywhere else.

One last thing, because the tools will have changed by the time you read this: the stack is disposable and the structure isn't. Models get swapped as better ones ship. Scripts get rewritten. But the sources of truth, the one-owner-per-domain rule, and the governance layer have outlasted every component swap so far. Copy the structure, not the shopping list — and before you buy anything, read the next chapter, because the rules should be installed before the horsepower.