a farm that grows where you dine
Indoor Hydroponic Automation System
To Be Named Labs designed and built an autonomous indoor hydroponic farm for a live hospitality space — industrial design, electronics, embedded firmware, and a local-first dashboard, as one team, running with zero cloud dependency.
- 256MBRAM, whole stack
- <20MBon disk
- 0cloud dependencies
- offlineby default
01 / seed
The brief: grow fresh food inside a working restaurant
A hospitality client came to us with a clear ask. Grow fresh produce on-site. Not in a greenhouse out back. Inside, where guests eat and staff work.
That changes the whole job. Every surface has to look intentional. Every system has to run silently. Nothing in a dining room gets to drip, hum or blink for attention.
The brief was clean. The reality, as always, was not. This became one of the most layered projects we've taken on. Not because of the technology. Because of what the technology had to disappear into.
We took it end to end: industrial design, electronics, embedded firmware and the dashboard. Four disciplines, one team, one cabinet.
02 / constraint
The real constraint wasn't technical — it was attention
Before we drew a single part, we mapped a restaurant shift. Guests and service eat most of the day. Kitchen prep takes the next big slice. Cleaning, setup, stock and admin fill the rest.
What's left for a farm in the corner? Under 1% of anyone's attention. On a busy night, zero.
That number became the design rule. The system runs itself. No daily checks, no manual dosing, nobody babysitting a pump. If it needs a human to stay alive, it fails in this room.
Everything after this — the form, the firmware, the offline-first architecture — traces back to that last 1%.
03 / form
Designing a hydroponic system that doesn't look like one
Automated hydroponic systems tend to look like what they are. A tangle of tubes, reservoirs, pumps and wiring, held together with brackets and optimism. That doesn't work in a dining room. Here, the look wasn't an afterthought. It was the point.
While we worked on the function, a metaphor kept surfacing: a tree.
A tree has one trunk. Water, nutrients and structure all flow through it. Branches reach out, each fed from the centre. Leaves at the ends do the actual work. One source, many endpoints, nothing wasted.
So we built the farm that way. A single central column carries water, nutrient delivery, power and data. The grow trays branch off it. Each tray stands alone but feeds from the centre. From across the room it reads as furniture. Up close, you see the tree.
04 / roots → trunk → canopy
One trunk: how the electronics and firmware are layered
The tree held further than we expected. It went all the way down into the electronics and the embedded firmware.
The main compute unit is the trunk. It holds state, runs schedules and makes every decision. Below it sits a real-time controller: the roots. It handles the physical world. Pumps, valves, sensors. Fast, precise, deterministic. On top sits the dashboard: the canopy. A window into the system for whoever needs to look.
Software follows the same shape. One source of truth. Every command flows through a single channel. No competing instructions, no race conditions, no two parts of the system fighting over a valve.
Living hardware leaves no room for ambiguity. Pumps move real water. Valves open and close on real plants. The tree doesn't send water in two directions at once.
05 / dosing
Nutrient dosing: add a little, wait, check
Nutrient dosing looks like a maths problem. Measure the water, calculate the dose, add it once.
The catch: the right dose depends on water volume, and volume moves all day. Plants drink. Water evaporates. Someone tops up the tank. Any estimate goes stale fast, and one big dose from a stale estimate overshoots.
So we copied how a careful grower works. Add a little. Wait. Check. Add a little more if needed. Sense and step, instead of compute and commit.
It's slower. It's also reliable in the way that matters: the reservoir lands in range whatever the volume turns out to be.
Same nutrient, same target band. Only the strategy differs.
compute & commit
EC 0.60
Estimate the volume, dose it all at once.
add · wait · check
EC 0.60
Small dose, let it mix, read, repeat.
06 / lean
The discipline of not overbuilding
Autonomous systems have a failure mode that has nothing to do with sensors. It's architectural. The moment a system acts without a human, the pull is toward more abstraction, more services, more surface area. It feels like engineering. It's usually the opposite.
We caught ourselves early. The core loop is simple: read the environment, compare it to what it should be, act if needed. That loop needs to be reliable, not clever.
So we built lean on purpose. Sensor orchestration, automation engine, command handling, dashboard and database all run on bare-metal hardware with under 256MB of RAM. No containers. No cloud agents. Nothing between the code and the machine that doesn't earn its place.
Timing matters too. Hardware circles call this the RAMpocalypse: AI's appetite for high-bandwidth memory has made RAM scarce and expensive. You design around memory now. You don't throw it at problems.
The whole stack fits in under 20MB of disk. We had enough RAM left over to run DOOM. Probably.
- orchestration engine
- Source of truth for decisions and outbound actions. State management, queueing, communication, health, memory management.
- local database
- Every reading and event stays on the device.
- web dashboard
- Live data, alerts, trend tracking, system control.
- automation engine
- Action, response, priority, scheduler.
- physical layer
- Fertigation, climate control, plumbing, lighting.
07 / offline-first
Designing for failure before features: offline-first by default
Early on we made a call that shaped the whole architecture. The system would work without the internet before we decided what features it would have.
Most connected devices get designed the other way round. Assume connectivity, bolt on fallbacks later. We flipped it. Offline-first means offline is the baseline, not the fallback.
That means local storage, local control logic, and a dashboard that loads on the same network with no internet at all. Remote access exists for support, monitoring and updates. It sits on top as a layer. The farm never depends on it.
Data doesn't vanish when the connection does. Analytics pile up locally and surface whenever someone asks.
The reasoning is simple. A dead plant in a client's dining room is a disaster. A slow dashboard is an inconvenience. We designed against the disaster first. That call is invisible when everything works. It's everything at 2am in a restaurant kitchen.
08 / the build
From rooftop to dining room
Renders don't grow basil. Here's the real thing mid-build: frame and trays on the workshop floor, grow lights tested at night on a Mumbai rooftop, polycarbonate going on, wires still taped down. We prototype in the open, mess included.
09 / the weak branch
Where we fell short: climate control
We're proud of what we shipped. We also want to be straight about where we didn't go far enough.
Climate control — temperature and airflow around the grow environment — was part of the brief. We built it. It works. It doesn't work at the level we know is possible.
The honest reason: we underestimated the tuning. Controlling climate is one problem. Controlling it well is another. Right response curves, right sensor placement, the interplay between airflow, humidity and temperature. That gap ran wider than we planned for, and we ran out of time to close it.
two days, two readings — the fight we didn't finish
What we shipped is stable and functional. What we wanted was climate handled with the same precision as nutrient delivery. That gap goes straight into the next iteration.
10 / canopy
What the project actually was
Looking back, this wasn't a technology project. It was a design problem that needed a lot of technology to solve.
The sensors, controllers and software layers aren't the point. The point is a space where fresh food grows reliably and quietly. A system that adds to the room instead of asking for attention. A chef walks past it every day without thinking about it, and still has fresh herbs when service needs them.
We got most of the way there. The tree stands. The branches are feeding. The leaves are growing. The next version will breathe better.
scens before delivering to the client