[Cover: a tangle of manual steps pulls taut, snaps and fuses into one file, setup_info.jsonc; a cable connects it to three ZeroBoxes one at a time, and the last one, after an error, is ready again as soon as it is plugged back in]
Device setup: from 20 minutes of work to 3 of waiting.
Case study · 2025
Giving developers back their time to develop
“How I redesigned Zerynth’s embedded-device setup in one month, leaving a base someone else would extend.”
Zerynth helps Italian manufacturing SMEs move to Industry 4.0, with a platform that collects and shows data from production machines. I had already worked there during my thesis, designing Zero, and in August, right after graduating, they called me back for a month. The task was to optimise a process few people see but everything else depends on, the setup of the embedded devices that collect data in the factory.
02 · The assignment
One month to optimise the workflow
The process was fragmented, slow, and kept alive by a document maintained by hand by those who knew it well. It had to stay with the developers, only faster and less exposed to errors from distraction, and leave a base the team would extend.
Another developer was already working on a more structural solution. So I knew my code would be replaced, and it had to be simple and readable rather than built to last.
03 · Isolating the problem
A process with too many sources, and many points of failure
For the first two weeks I worked alongside the developers, noting down their times, and set up devices several times myself, until I went from hours to 15 minutes per device.
The real problem was that everything depended on the memory and attention of whoever ran it. Between calls, meetings and breaks it took little, a wrong password or a misplaced file, to start over.
[Image: the old process in six numbered steps (read, create the asset, firmware, VPN, setup, Excel), with the points where people got lost marked on the interfaces: the name typed by hand, the firmware to pick, the VPN that can’t be fixed, the wrong password or network, the copy into Excel]
There were three sources of files for a single device, and every hop from one to another was a chance to get lost.
04 · The goal
How do I give developers back the time and attention the setup was taking?
Tidying up the document would not have been enough. The order of the actions themselves had to change, bringing human decisions to the start and the end and automating everything else.
05 · The solution
Everything before, everything after, no steps in between
Before
One file to fill in holds all the information needed.
In between
Two automatic commands turn that file into ready devices; the user only connects them.
After
A summary says what worked and what didn’t, and fits into the way of working that already existed.
06 · Key design moments
Working for the future, within constraints
Every choice had to make the process more stable today and leave a base for the team’s final solution.
JSON
Moving every problem to one place: the JSON
The information once given step by step all moved to the start, into a single JSON, a format that can be validated and that a graphical interface or an agent could later fill in instead of a developer.
[Image: the new process, the setup_info.jsonc file holding the checks that used to be scattered, then the --asset and --deploy commands, then the deploy summary ready to copy into Excel]
Decision: Every point of failure ends up in the JSON, and so the risk moves from setup to compilation.
The cost: the process had to be rebuilt around the file. But a JSON can be validated and three scattered sources can’t, so if a piece of data is missing no command runs and the developer sees at once what is missing.
The firmware follows the same logic too, with a standard one for every device, replaced by a custom one only when needed.
Summary
Fitting the setup summary into the old process
At the other end of the process I put a summary, which lists for each device what worked and what didn’t. So running the setup again restarts only from the devices left, and deleting that file starts everything over.
[Image: the tool’s final report in the terminal, one row per device with completed, failed or pending status and the counts]
Decision: The Excel sheet that tracked the devices couldn’t be automated, so the summary leaves a message ready to paste into it at the end, instead of a step halfway through.
deploys to the connected devices · a device that fails ends up in the summary
Decision: Between the JSON and the summary, setup goes through two commands, one creates the assets (with or without VPN) and the other deploys to the connected devices.
First attempt: The alternative was to merge them into one.
The cost: two different moments mixed together. Creation validates the JSON and stops before touching a device; deployment gathers all the physical work at the end, and a device that fails ends up in the summary without blocking the others.
When everything is ready, they can still be run one after the other.
Bzzz!Bzzz!Bzzz!
[Sound: the buzzer goes “Bzzz!”]
Distraction remained, though, and a way was needed to call back attention when a device had to be unplugged or something failed.
Decision: I reused the buzzer that already locates devices in the factory, as the process’s sound signal.
VPN
Working together to clear technical debt: the VPN
The VPN was still missing. Creating one was complicated, and deleting it without leaving traces on the production server wasn’t a given.
First attempt: I could have left it out of scope, and saved time.
The cost: a manual step left in the middle, just as I was moving all the others to the start or the end.
Decision: With the Head of Hardware Engineering we tested a solution on a staging server and took it to production. Creating and deleting a VPN became two commands, and the automation was complete.
What I left in Zerynth’s roadmap
From my work, Zerynth could expand in two ways:
1
An agent that fills in the JSON instead of a developer, reading the handoff document and the dashboard data, that is the idea of Zero brought upstream of the process. The Zerynth team worked on it after me.
2
A graphical interface on top of the JSON, for those who don’t know the format.
Both were foreseen when I designed the JSON.
07 · Impact
Impact
[Image: minutes of work as devices grow, before about 20 per device up to 120 for six, after the JSON once (about 10) and about 3 automatic per device up to 28; the area between the lines is the time saved]
The work on a device drops from 20 to 3 minutes [note 1]. The JSON is filled in once, then it’s enough to connect and swap the devices while setup runs on its own, and the rare errors are picked up at the end. Someone seeing it for the first time now works on a par with those who knew it by heart. I delivered the tool, the new flow and the documentation; the tool is no longer used today, but it was the base of the final workflow.
1Before, about 20 minutes on average, from the times I noted down working alongside the developers, so 3-4 devices an hour, and those who had found a method of their own were faster. After, the JSON is filled in once for the whole batch, about ten minutes at most, then about 3 minutes per device, automatic and mostly waiting for boot and image writing, while the person connects and swaps devices. Both are averages, but the first changed a lot from person to person, while the second barely varies because the tool does the work.
08 · What I learned
What I learned
Sometimes the simplest design comes from rearranging what exists.
Moving human decisions to the start and the end fixed more errors than any rewrite of the document.
A base meant to last is worth a small cost today.
The JSON, the separate commands and the summary all had in mind whoever would extend the work later.