One executable file weighing around 10 MB, a startup time under 20 milliseconds, and less than 25 MB of RAM—that's how the HomeStorage address-based home inventory system runs under the Apache-2.0 license. Developer Evgeny (@GraviJohn) stripped out everything people usually drag into side projects out of habit: PostgreSQL, SQLite, Redis, Nginx, and Docker. The entire database sits in one human-readable JSON file, and the React 19 interface is compiled straight into the binary.
Why a Garage Needs Its Own WMS and Why the Cloud Gets in the Way
It's a familiar scene: leftover building materials, car parts, hobby supplies, and gear like skis pile up in the garage and closet for years. Eventually, it feels easier to buy a new part than to dig through ten boxes looking for the old one.
Real warehouses solve this with a WMS—an address-based storage system where every rack, shelf, and container has a short code. Corporate tools are way too heavy for a family, though: they expect servers, user roles, and steady internet. Cloud apps get annoying fast too—Wi-Fi barely reaches the basement or garage, and nobody wants to pay a monthly subscription just to track their own screws.
That shaped simple goals for a home tool. Offline-First operation on the local network, so it feels snappy on both a desktop and an old phone in the basement. No logins or passwords inside the family, so household members actually use it. Quick photo capture right inside the add-item form without cluttering your phone's personal gallery. And backups done simply by copying one data file and one photo folder.
Backend in One File: db.json, sync.RWMutex, and //go:embed
The backend is written in pure Go (net/http) with zero external dependencies. The entire structure of locations, categories, and item cards lives in memory inside DatabaseSnapshot and serializes to a single readable db.json file.
To keep requests from multiple tabs from clashing or writing half a file, concurrent access and atomic overwrites use Go's standard sync.RWMutex. It's a read-write lock: RLock lets many readers run in parallel, while Lock hands the file to a single writer for a fraction of a millisecond until the snapshot is safely on disk.
The built frontend (dist/) is packed right inside the program using //go:embed—a special compiler comment that bundles static assets into the final binary.
// Embed the built React frontend inside the Go binary
//go:embed all:dist
var staticFiles embed.FS
// Store protects the db.json snapshot from write races
type Store struct {
mu sync.RWMutex
data DatabaseSnapshot
}
The output is a single file for Windows, Linux, macOS, or Raspberry Pi that you can easily run as a service via systemd or NSSM. Building the project takes four commands.
# Build frontend static assets with Vite
npm install
npm run build
# Compile the Go backend without debug symbols
cd go-backend
go build -ldflags="-s -w" -o inventory.exe main.go
The -s -w flags strip symbol tables and debug info, shrinking inventory.exe to roughly 10 MB. At launch, the server immediately serves the UI, handles API requests, and stays under 25 MB of memory.
Photos aren't base64-encoded or sent to object storage. Images sit on disk in subfolders matching the storage code and name, such as uploads/h-c1-s3-b1_Box_1/. Each filename starts with [item_id]_[timestamp]_[rand].jpg. That simple naming scheme replaces a pile of code: when deleting or moving an item, the server checks the prefix in constant O(1) time, leaves other items' photos in the same box untouched, moves the right files to the new folder, and removes the old empty directory.
Frontend for the Garage: Nesting, Camera Capture, and Spotty Wi-Fi
The client is built with React 19, TypeScript, Tailwind CSS v4, and Vite. All logic fits a strict four-level "nesting doll" hierarchy: Location (Home) → Furniture (Cabinet) → Shelf (counted bottom-up) → Container (Box).
You can drag and drop shelves and boxes between cabinets. On any move, the client and server stay in sync, recalculate short codes like h-c1-s3-b1, and block circular references.
Safe Deletion protects against hasty mistakes: the system won't let you delete a shelf or box if it or any child container holds at least one item. Instead of wiping data, it lists the items inside and prompts you to move them. Click around the mockup below to see how the address code, file path, and delete check react.
Interactive Mockup: Address Code, Photo Path, and Safe Deletion
The exact same address code goes onto the paper sticker, the UI tree, and the folder name on disk. Even if the app stops running five years from now, you can open uploads/ in your file manager and still make sense of everything.
Idempotency handles basement Wi-Fi drops: submitting a form twice with the same unique ID updates the existing entry instead of creating duplicates. Deduplication runs on both sides, in inventoryStorage.ts on the client and storage.go on the server.
For snapping parts from a smartphone, a single HTML capture attribute set to environment was enough.
<!-- Opens the phone's rear camera directly (use 'user' for front) -->
<input type="file" accept="image/*" capture="environment" />
The mobile browser skips the photo gallery and opens the main camera immediately. And if you snap a photo of some bolts, change your mind, and close the form without saving, the client fires DELETE /api/upload right away so orphan files don't pile up on disk.
Label Printing, Offline Fallback, and the Limits of Minimalism
Sticker generation runs entirely in the browser: the qrcode library draws QR codes on an HTML5 Canvas, while a custom SVG generator builds Code-128 barcodes for thermal roll printers and A4 sheets.
Client state is wrapped in InventoryStorageManager. Real-time substring search scans names, SKUs, barcodes, dimensions, notes, categories, and address codes at once. When the page loads, the client tries to sync with the server via syncWithServer, and if the backend isn't reachable (say you opened a static demo), it seamlessly falls back to localStorage. On top of that, it supports 11 languages—including RTL (right-to-left layout for Arabic)—using LanguageContext and a plain JSON dictionary.
This minimalism comes with two clear trade-offs. First is scale: db.json under sync.RWMutex handles 1–5 users and thousands of cards effortlessly, but with tens of thousands of items and frequent concurrent writes, rewriting the whole file becomes a bottleneck. At that point, you can switch to SQLite (via modernc.org/sqlite in pure Go) without losing the single-binary format, or step up to PostgreSQL for dozens of staff and roles.
Second is security. Skipping passwords only makes sense on a trusted home network. Never expose HomeStorage directly to the public internet: for remote access, put a reverse proxy with authentication in front of the binary or connect over a VPN.

![Node.JS [ru]](/api/digests/it_development/daily/20261122/assets/sources/we-use-js.jpg?v=8a922c4c9193ead8575dd869ae7a5dafe5bd8590efaaa20c7d3842b3cedee257)