How to monitor house from terminal

When a Show HN post titled “track your house from terminal” receives 657 points and 218 comments on Hacker News, many readers expect another home-automation controller. Micasa is a keyboard-driven terminal UI that stores details about your property, maintenance schedules, appliances, vendors, projects, and quotes in a single SQLite file on your own machine. It does not use the cloud, require an account, or a subscription, and nothing is sent to a server unless you connect a local model yourself.

The project, written in Go by the developer behind the cpcloud handle, has reached 1,276 stars and 56 forks on GitHub since its launch. The repository was created in February 2026 and remains actively maintained as of September 2026, with about 1,288 commits and 60 open issues. It is released under Apache License 2.0. The focus is narrow: it replaces a disorganized collection of receipts and notes apps where users jot down “I’ll remember that,” targeting those who prefer working in the terminal.

A clarification before the details: several early articles described Micasa as a tool to “track smart home sensors” or “control devices.” That is inaccurate. The official site and GitHub README describe it as a records system for home maintenance, projects, incidents, and costs. It does not interface with thermostats or lights. Data ownership and storage are the main design considerations and require close attention.

What Micasa Actually Tracks

The data model uses a relational schema with about a dozen entity types. The developer documentation on DeepWiki lists the core tables that the TUI exposes as tabs. The table below summarizes user-facing entities and their contents, based on the project’s architecture documentation.

Trade-offs of single-file storage in Micasa

Entity	What it holds	Key relationships
HouseProfile	Property details, move-in date, ownership info	Root entity with no parent
Project	Renovation plans, cost tracking, status	Has quotes and documents
Appliance	Equipment records, warranty dates, purchase info	Has maintenance items, service logs, incidents
Vendor	Contact directory and service history	Referenced by projects, quotes, incidents, service logs
MaintenanceItem	Recurring tasks with auto-computed due dates	Belongs to appliance, has service logs
ServiceLogEntry	Work history, date performed, notes	Belongs to maintenance item, references vendor
Quote	Price comparisons and vendor proposals	Belongs to project, references vendor
Incident	Problem logging with severity tracking	References appliance and vendor, has documents
Document	Files stored as BLOBs	Attached to projects, appliances, incidents

The Design Bet: One SQLite File Holds Everything

The main architectural choice is storing the entire app state in a single SQLite database. Documents such as manuals, receipts, and photos are embedded as BLOBs inside that same database file rather than stored as external file paths. The official site states this clearly: single SQLite file, no cloud, no account, no subscription, with backups done by copying the file.

This decision has practical engineering effects. Because everything is in one file, backing up the entire household record involves copying that file. The built-in backup command uses SQLite’s online backup API to create a consistent snapshot without locking the database, then runs an integrity check. A simple file copy also works, which is the main goal of this design.

The stack is pure Go with no CGO dependencies. The TUI is built on the Charmbracelet stack, especially Bubble Tea, which follows the Elm architecture of model, update, and view. GORM handles object-relational mapping, and the SQLite driver is a pure-Go implementation. The result is a single static binary that runs on Linux, macOS, and Windows, with installation options including the Go install command, prebuilt binaries from releases, a Nix flake, and a container image.

The default database path follows platform conventions, placing the file under the user data directory for each operating system. Demo mode seeds a sample house into an in-memory database so users can explore without adding their own data, and a scaled demo flag can generate decades of simulated history. The author jokes in the launch thread that you can run the demo with a thousand years of generated data, though no house is likely to last that long.

The Trade-offs of Single-File Storage

The most significant critique of Micasa comes from its own author. In the Hacker News launch post, cpcloud says that if you expect the single-file model to scale well, you will be disappointed, but it remains easy to work with. For a household dataset, which is small and single-user, the model works well. For larger or collaborative use, it becomes limiting.

Document attachments stored as BLOBs increase the database file size directly. A few years of scanned receipts and contractor photos can push the file into the hundreds of megabytes, and every backup copies the entire file. SQLite handles this size without issue, but the tool does not provide incremental or partial backups. You either copy the whole file or lose backup granularity.

Concurrency is another limitation. One SQLite file allows only one writer at a time, which works for a single user on one laptop but is problematic if two people want to update records simultaneously. There is no synchronization, merging, or mobile companion app. If multiple people maintain the file, they must coordinate manually.

The tool focuses on being a specialized ledger rather than a general task manager. Independent notes, including one from Ryan Orban, describe the niche clearly: it suits a developer who finds a dedicated terminal app more efficient than a spreadsheet or home-management app and who has enough ongoing maintenance to justify systematic tracking. The x-cmd write-up adds that the tool does not cover family calendars or general to-do lists and works best as a durable record for ongoing household projects.

A fourth point, related to the project’s development, is that most of the code was written by an AI coding agent. The author states in the launch post that 99 percent of the programming was done by the agent while he reviewed the code and merged changes. For a low-stakes personal tool, this workflow is reasonable, and the project maintains a security policy and runs vulnerability scanners. However, anyone adopting the tool should treat it like any young, quickly written codebase: review the source before trusting it with years of personal records and keep backups current.

The Optional Local LLM Query Layer

Micasa includes a chat feature that the author calls a gimmick, added partly to address the “but does it AI?” question. All core features work without it. Pressing the chat key opens a prompt where you can ask questions in plain English, such as how much you have spent on plumbing this year.

Behind the prompt is a two-stage process. The tool connects to a local Ollama server or any OpenAI-compatible API. It reads the database schema and some column values, translates your question into SQL, verifies that the generated statement is read-only, and runs it against your local data. It then sends the query results back to the model to summarize them in prose. If SQL generation fails, it falls back to sending the relevant data to the model for interpretation.

The privacy aspect is important. Because the model runs locally or on an API you explicitly configure, your household data does not leave your machine during normal use. Ryan Orban’s review points out a practical use: asking whether a quote is reasonable for a specific type of work. That is a useful query against a ledger that holds past vendor prices.

The limitation is that the feature depends on the model and schema hints. Local models vary in their ability to generate correct SQL from natural-language prompts, and the two-stage design means a wrong query can produce a confident but incorrect answer. For a read-only analysis tool, this failure mode is acceptable, but it does not replace reviewing the data yourself.

Where Micasa Sits Among Home-Management Tools

Looking at other options homeowners have clarifies Micasa’s role. The default tools are spreadsheets or notes apps, which the author wanted to move beyond. Spreadsheets offer flexible columns but lack relational structure, due-date computation, and attached documents. Micasa provides a schema, auto-computed maintenance dates, and BLOB attachments all in one file. If you are considering how to organize your own data, the practices around data modeling and error handling in API design provide useful parallels for understanding how records relate.

At the other end are property-management platforms and home-automation hubs like Home Assistant and openHAB. Those tools focus on controlling and monitoring devices and environments. Micasa records facts and history instead. These two categories complement each other: you might use Home Assistant to monitor a leak sensor in real time and Micasa to keep the service history of the pump that sensor watches. Early articles that grouped Micasa with “smart home control” blurred this distinction, which is why it is important to state it clearly.

The straightforward comparison is with the manual systems Micasa replaces: a box of receipts, a sticky note on the fridge, and a notes app full of reminders. Compared to those, Micasa provides relational structure and durable storage. The trade-off is that you need to be comfortable using a terminal and willing to maintain a single local file. That limits the audience, and the tool does not claim otherwise.

A 2026 Verdict, With Caveats

As of September 2026, Micasa is a young but active project with a clear focus. The single-file, local-first approach offers an alternative to subscription software, and the keyboard-driven interface is well designed for its target users. The repository shows steady maintenance, and the author engages with users in the launch thread.

The limitations are clear. Single-file storage means backups are all or nothing, and the file grows with every attached document. The tool is designed for single users, with no synchronization for households sharing work. The code is mostly AI-generated, so users should review the source and keep backups current before relying on it for long-term records. The local LLM feature, while clever, is optional and imperfect.

For a developer who works in the terminal and owns a house, Micasa deserves consideration. Try the demo, add a furnace filter and a real quote, and see if the keyboard workflow improves on the spreadsheet you already dislike. The official site, GitHub repo, and launch discussion are good places to start. The tool will not manage your smart home, but it will provide a private, durable record of the one you live in.

More in-depth coverage from this blog on closely related topics:

Sources and References

Sources cited while researching and writing this article: