Francesco Paderi
[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.”

Role
Process & Tool Design
Team
Zerynth developers; Head of Hardware Engineering, Zerynth
Timeframe
1 month

20 → 3

Minutes of work per device · observed average; now mostly waiting

After graduating, I go back to Zerynth

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.

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.

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.

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.

Everything before, everything after, no steps in between

  1. Before

    One file to fill in holds all the information needed.

  2. In between

    Two automatic commands turn that file into ready devices; the user only connects them.

  3. After

    A summary says what worked and what didn’t, and fits into the way of working that already existed.

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.

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.

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.

Preparing the devices: create and setup commands

terminal

python -m setup_v11_with setup_info.jsonc --asset

creates the assets (--assetVPN also makes the VPN certificates) · validates the JSON and stops before touching a device

python -m setup_v11_with setup_info.jsonc --deploy

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.

[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.

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.

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.

  1. 1 Before, 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.

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.

Get in touch

CV
Directed by
Francesco Paderi
In collaboration with
Claude Code
Portfolio inspirations
Jean Chen
Rachel Chen
Moved by
Gawx
The Lumineers
Eve
Fuelled by
Lots and lots of tea
All kinds of music
(from metal to Baldur’s Gate themes, with a bit of pop and indie in between)
Type
Fraunces · Instrument Sans · DM Mono
Subtitles
EnglishItaliano [a click switches the site’s language]
Disclaimer
No AI agents were harmed
in the making of this site
(except Claude, a little)