GolemPi

The problem underneath the brief

Almost nobody building on Ethereum talks to Ethereum directly. They go through a public RPC provider, Infura above all, because running a node yourself means hardware, sync times and maintenance. It is convenient and it has a cost. That provider can see which addresses you query and from what IP. When it goes down, large parts of the ecosystem go down with it, as happened when outages forced exchanges and wallets to suspend withdrawals. When sanctions arrive, it blocks whole regions. A chain that settles without permission is reached, in practice, by asking someone for permission.

GolemPi was the answer in object form: your own node, your own connection, nobody logging your queries.

The brief

Golem needed a way to show what its network could carry, and slogans were not landing. The plan was to build the argument instead of writing it: a short run of devices for the community, each one running a full Ethereum node on Golem hardware. It was paid for out of the marketing budget and specified like a product. It had to survive being unboxed by strangers who would post about it either way, which meant designing it as a product rather than as a giveaway.

The board added a requirement that was not technical at all: it had to be a good looking object, something you leave out in a room and someone asks about. A node nobody wants on their desk does no marketing whatsoever. That single sentence is why the industrial design got the budget and the attention it did.

Designing the device

I co-authored the creative design of the device with Joanna Janiuk-Muszyńska. The form is a literal reading of the idea: the Ethereum logo sits on top, and the base is half a Golem network node, drawn from the bubble language Golem already used for nodes. You can explain the whole project by pointing at it.

It is passively cooled, so it runs quietly enough to sit on a desk rather than in a cupboard, and it is small enough to stand next to a monitor. The Ethereum logo on top is backlit and reports the node's status by how it glows. The node arrives preinstalled and fully synced, and there is a printed guide in the box, because the first five minutes decide whether a thing like this gets used or shelved.

Two things we took out

The first plan was a plastic case with a display, close to what Web3 Pi ships today. Internal testing killed both.

The fan. The device ran hot, and fast. The obvious fix was active cooling, and the obvious problem with active cooling is that a cheap fan is the first part to die. On a node whose whole value is being up, a failure point that ships broken in eighteen months is not a detail. So we went the way Apple goes: solve it with the body instead. Passive cooling meant a heavier, more expensive enclosure and a node that stopped shutting itself down. Reliability was the product.

The screen. There was a long argument about the display. I pushed to remove it. The Ethereum logo on the front was already a cutout with LEDs behind it, so the device could speak without a screen: green for running, blue for updating, red for an error. A glance across the room tells you what a display would have told you, at a fraction of the cost and complexity, and without putting a small ugly panel on an object meant to sit on a desk.

The mark

The device needed its own identity, close to Golem but not swallowed by it, so I drew one. The mark is gπ: the g from Golem, the π from Raspberry Pi, set in a light serif that reads as a scientific instrument rather than a crypto product. The whole name is in two characters, and it works at 4mm.

That mattered, because most of its life was spent engraved rather than printed. I specified the application: logo height, margins, and placement on the front, top and base of the casing, drawn against the physical part rather than on an artboard. A Signature Edition lockup extended it for the presentation units. The Golem wordmark stayed on the underside of the base, where it belongs on a device that is not a Golem product but is made by Golem.

The same mark carried the packaging: a plain white box with the gπ in copper foil and nothing else on the lid. Restraint is cheap to print and hard to get wrong at the unboxing.

Getting it made

Robert Mordzon ran the technical production, and I supervised it creatively from the other side: what the object had to look and feel like once it stopped being a render. That meant sitting over quality control on many iterations from several suppliers, judging case finish, colour against the sampled options, and build quality unit by unit. I also designed the packaging, since on a device meant to arrive as a gift the box is the first interface anyone touches.

The desktop application

I designed the whole application, and an external front-end developer built it. I worked directly with the board and the dev team throughout, which is what kept the scope honest.

I interviewed Web3 developers who were writing applications on Ethereum and needed a node of their own to work against. It was the least romantic research I have ever run, and the most useful. There are no journeys. There is an endpoint. A developer needs Ethereum data for their application, they point the application at an endpoint, they occasionally check that the network is alive, and that is the entire relationship. Ninety nine percent of their attention is on their own product, not on Ethereum.

So the application stopped trying to be a destination. Its job is to hand over a working endpoint in as few steps as possible and then stay out of the way. The one place worth designing carefully was the dashboard, so I asked the same developers to weight the pieces of network information by how much they actually cared, and built the information architecture in that order, most important at the top, down to the things they said they would look at once a month. The hierarchy is theirs, not mine.

The screens follow from that. Setup opens on the device rather than on a form, so the first thing on screen is the object you have just taken out of the box. After authentication the only question left is how long the browser should remember it, and from there the application stops asking you for things. The home screen stays short on purpose: firmware state, a way into the Ethereum node, and the option to run a Golem node alongside it. Everything else waits until you go looking for it.

The endpoint itself is the product, so it is handled as its own object. A developer creates a project, and the project carries a name, an ID, a secret and an RPC endpoint they can paste into their application. Several projects can run against the same node, which keeps one dApp's traffic readable apart from another's, and it keeps project configuration away from node administration. Those are two different jobs and the people doing them are often in two different moods.

Who it was for

Power users, and that was a decision rather than an assumption. The devices were going to people who already knew what backing up an ETH address means, so the application never explains crypto to anyone. It follows the patterns that audience already uses, the industry standard ones, and spends its attention only on what was genuinely new here. Designing this for beginners would have patronised the people receiving it and slowed down everyone who knew what they were doing.

What it became

The next phase was always meant to be opening it up, and that is the part that survived. The custom enclosure and the passive cooling did not: they were tied to a production run that never went out. The software, the documentation and the thinking did. The project continues as Web3 Pi, an independent community driven effort supported by the Golem Ecosystem Fund. Everything is open source, so instead of waiting for our enclosure you take a Raspberry Pi and parts you can buy anywhere, and build the same thing at home.

The part that matters most in design terms went with it: you do not configure the node. You download the software and it configures itself. Standing up an Ethereum node by hand is the wall that keeps almost everyone on somebody else’s RPC, and taking that wall down was always the real product. The enclosure was how we made people want to.

In that form it has gone much further than the boxed version ever would have. Web3 Pi and Golem have since kept 200 Ethereum validators running on a single Raspberry Pi 5 for more than 250 days, on real stake, performing alongside professional setups. The object did not make it. The argument it was built to make did.