By Mariah Balzan10th Sept 2026Craftsmanship6 min read

Two Kiosks, One Job

What a donation tablet and a Raspberry Pi dispenser have in common — and where “finished” means completely different things.

Two Kiosks, One Job

A kiosk sounds like a simple thing to build. A screen, a button, maybe a card reader. How different can they really be?

Very, it turns out. We built two recently that could not be more unlike each other. One is a tablet in a theatre, locked into a single donation flow — a visitor taps their card, gives what they want to give, and walks on. The other is a dispenser in schools, built on Raspberry Pi hardware with no touchscreen at all: three physical buttons, a QR scanner, and a motor that drops a product when a pulse fires.

Different stacks, different constraints, different everything — except the job. Both machines exist to remove noise. The donation station clears the friction from giving: no queue, no envelope, no awkward hunt for change. The dispenser clears something quieter — the awkwardness of having to ask. A student scans a code and the machine hands over what they need, no conversation required.

Same intention, different hardware. That’s the lens for everything that follows.

Permission without identity

The dispenser’s whole interaction takes seconds. A student scans an anonymous QR code, the system checks they’re permitted to use the machine, and a GPIO pin fires a pulse that drops a product. No account. No login screen. No personal data stored anywhere.

That last part wasn’t an accident of the simple hardware — it was the design decision the entire system was built around. The machine was engineered from the start to know only that someone is permitted, never who they are. It can’t leak what it never collected. Nobody has to trust us with a database of which student took what, because that database doesn’t exist.

It would have been easier to build it the ordinary way — accounts, logins, a record per dispense. Most of the tooling assumes you want one. Choosing not to know is the harder path, and it’s worth naming why we took it: a machine serving young people in a school shouldn’t make anyone weigh their privacy against their need. The dignity of the person using it was a requirement, same as the pulse timing.

Taking ourselves out of the way: the client owns the kiosk

The donation station makes the opposite trade — it’s all software — but the same instinct shows up in a different place.

When something on that kiosk needs to change, there are three routes, depending on how deep the change goes. The first belongs entirely to the client: a settings layer built into the kiosk itself, protected behind a PIN with lockout after repeated failed attempts. From there they can tailor the kiosk to how they like it — the suggested donation amounts, the wording, the branding — all without calling us. The second is ours, but invisible: when something needs fixing in the app itself, we ship it as an over-the-air update from our own desks, and the kiosk quietly picks it up. And the third is the honest one to name: when something needs fixing at the native layer, an update pushed over the air isn’t enough — we make a new build and implement it on site.

The easy version of this build would have made us the bottleneck for all three: every tweak a ticket, every wording change a request through us. That’s good for invoicing and bad for everyone else. Instead, the layers are ordered so the client handles the everyday themselves, we handle the rest as lightly as it allows — and we only show up in person when the work genuinely needs us there. If a partner can only operate what we built by keeping us on the phone, we haven’t finished the job — we’ve just made ourselves permanent.

When you can’t patch it, the prototype is the deliverable

Here’s where the two kiosks genuinely diverge — not in what they’re for, but in what “finished” means.

The donation station lives almost entirely in software. If the wording is off or an error state confuses someone, we can adjust it in an afternoon from our desks — only a change at the native layer sends us to site. Finished is a moving target, and that’s fine — the system is built to keep being finished.

The dispenser doesn’t work that way. It lives in wiring, motors, and a signal pulse that either fires or it doesn’t. Stock levels that decrement with every dispense and get replenished by a maintenance card. A monitor that physically switches on and off on a schedule, run by the same GPIO logic as the dispensers. Machines going offline on patchy school wifi, needing to know what to show while they wait to reconnect. None of it can be patched with an app update. If something’s wrong with the hardware, someone has to be there in person.

That changes how you build. There’s no framework for “make sure the pulse is long enough to trigger the motor but short enough not to jam it,” no Stack Overflow thread that quite matches your board. So both projects — but the dispenser especially — started with a quiet phase before any interface existed: research spikes, hardware testing, small prototypes built only to answer whether this even works the way we think it does. On the tablet, that phase de-risks the build. On the dispenser, it is the build. When you can’t patch it later, the prototype isn’t a rehearsal — it’s the deliverable. Whatever you didn’t answer before install day, you’ll be answering in person, in a school corridor, with a screwdriver.

That’s the thing worth taking home if you build software for a living: ask early whether your project can absorb mistakes after launch. The answer decides where the real work happens.
And here’s the quiet reward for doing that work properly: you only do it once. The pulse timing, the offline behaviour, the stock logic — once those questions are answered, the same software runs every machine after the first. The client doesn’t commission kiosk number two; they just plug it in. Ten dispensers or fifty, the engineering is already done. The hardware multiplies; the thinking doesn’t have to.

Range is the side effect

The same team moved between the two in the same quarter — from tuning a payment integration’s error states to debugging hardware pulse timing — and honestly, that’s the part of the job I enjoy most.

But the range isn’t the point, and it was never the goal. Both kiosks exist to do the same thing: take a small piece of noise out of someone’s day. The friction of giving. The awkwardness of asking. Everything else — the stacks, the prototypes, the GPIO pins — is just what it took to get there.

Delivery looks different depending on what you’re delivering. The standard doesn’t move. That’s the part we’d want anyone standing in front of either machine to actually feel.

Don't miss anything

Stay connected and never miss our latest news and updates!