The form we actually trust

28 May 2026

3 min

In February 2026, we replaced our contact form with a submission pipeline we built and own.

For the two years before that, it was a Pipedrive iframe inside our page. We had no control over fields, no client-side validation, no error handling beyond whatever Pipedrive showed inside its frame. When a submission failed, we found out from the client, not the system.

A screenshot of the new form we designed, built and tested. A form we built, designed and control.

Two forms, one pipeline

The start-a-project form is the full version: budget, brief, file upload, preferred dates, auto-detected timezone. It’s built as a Preact component with React Hook Form and Zod handling validation on the client. A minimal variant, just name, email and consent, runs on the AI Brand Engine page where a lighter touch makes more sense.

Both variants share the same submission pipeline. Different form surfaces, identical processing underneath. Every entry point gets the same validation, error handling and recovery, regardless of which page the inquiry came from.

The pipeline

The submission pipeline handles the sequence after the form is sent: validate with Google Recaptcha, create the contact and lead in our CRM, attach any uploaded files and send a confirmation email. Newsletter signups follow a shorter version of the same flow.

Both pipeline functions accept a typed dependencies object and every external service is injected rather than imported directly, which keeps the pipeline decoupled from its environment and makes each service boundary explicit. (How this enables testing is covered in a separate post.)

When things go wrong

If the lead is created but a secondary step like file upload fails, the submission still returns success to the user. The lead is safe. A structured alert fires to our team channel with enough context to recover manually.

Fatal errors, when the lead itself fails to create, alert the team with the same detail and rethrow so the user sees an error state. Nobody loses an inquiry silently.

Zod on both ends

The server-side actions run the same Zod schema again on the incoming data. Same validation, different boundary. A tampered request that bypasses client-side checks gets caught before it reaches the CRM.

From the user’s side

A form that validates as they type, shows clear error states when something’s wrong and lands on a confirmation screen with links to Labs and our Instagram, not a generic “thank you” page. They don’t know about the pipeline. They just know the form worked and the response didn’t feel like an afterthought.

The contact form's success state: "Thank you! We've received your submission and will reach out within 24 hours," followed by links to our Instagram and Labs, sitting below the form's privacy checkbox and Submit button. The success screen — links to Labs and our Instagram, not a generic thank-you message.

Since the pipeline went live in February, every submission failure has alerted the team within seconds, with enough context to recover manually.

Letting type move

Charlie Clarke

Field Notes

16 June 2026

5 min

We treat type as something that sits still — fixed in place, headings always the biggest thing, motion bolted on at the end. For one Creative Spark we dropped those rules and asked what type could do once it started moving.

Creative Spark is our in-house R&D session: ninety minutes, a single theme, and a room full of people building prototypes with no client to please and nothing due at the end. This time the theme was type in motion. We wanted type to feel less like a fixed shape that carries information one way and more like a material with some give in it. But the afternoon turned out to be about something bigger than typography: how cheap and fast exploring an idea has become, and what that does to the way a studio spends its time.

What we questioned

A few of our assumptions went early. Weight can change mid-word. A heading needn’t be the biggest thing on the page. Motion has to do a job rather than decorate, without sliding back into the hyperactive web of 2002. Most of these aren’t rules anyone chose on purpose; they’re hangovers from how web type is built, all CSS axes and classes, and that machinery sands the creativity out of it. The tooling has moved on, though. The new AI font editors make a bespoke cut of a typeface cheap enough to try on a whim, so the cost of asking “what if the type did this?” has more or less collapsed.

Whiteboard reading "Type in Motion — challenge these assumptions", ringed with notes on fixed shape, one-way communication and scale as hierarchy The framing board: every assumption about type we wanted to push on.

What we made

Six prototypes came out of it, all over the map. One was a 3D dial you turn instead of scrolling a list. Another tied typography to scroll speed, so the text frays the faster you go. A few used the camera, with hand and face tracking that shoves the letters around — very Minority Report. There were soft-body letters that behave like balloons, bouncing on gravity and anti-gravity. Someone rebuilt the dial from scratch in plain JavaScript and CSS in about ten minutes, from a JSON spec and a reference URL, just to see how close standard web tech could get. None of them were precious, and that was the idea: enough range, fast enough, that binning most of it still leaves you ahead.

Green jittery type on a pink field reading "the web has genuine capabilities for type that almost nobody is using", with radius, jitter and strength sliders Typography wired to scroll speed: the faster you go, the more it frays.

The dial rebuilt in plain JS and CSS: a radial nav that drifts with scroll momentum.

What we took away

The making turned out to be the cheap part. We settled on a cheap, fast model to churn out the bulk and a slower, pricier one to tidy up after it; the whole multi-model run came to about £1.40. For the price of a coffee we had a spread of directions that would normally take days to work up. When making the thing is nearly free, the hard part isn’t the making any more — it’s knowing which of the six is worth pursuing, and why.

A couple of things caught us out. You can do proper hand and camera tracking in the browser now with no extra software, which none of us knew. And the move off loose “vibe coding” onto structured prompts and JSON build specs mattered more than any clever wording. The boundaries kept the models from wandering and handed back code we could actually use.

A particle-dust rendering of the word "MAGIC" with a "hand detected" badge, driven by webcam hand-tracking “Magic”, revealed by hand-tracking through the webcam — no plugins, just the browser.

The speed stuck with me most. We started with a vague theme and, ninety minutes later, had a handful of working, clickable prototypes. That’s the kind of session I’d put a client in the room for: not to show them finished work, but to let them watch an idea become six things they can click before lunch.

A four-panel grid of more prototypes from the session: glowing "type is alive" variable-font text, a radial 3D navigation dial, a split-flap departures board, and ghosted type set over a landscape photo A few more from the room: a variable-font study, the 3D dial, a split-flap departures board, and type set into a landscape.

Magic and logic

There’s a split underneath all of this. The balloon letters showed it. Motion looks right when it obeys physics — mass, gravity, the way a soft body overshoots and settles. That’s the logic. A model holds it without effort: the easing curves, the equations, the maths of how things move. You can hand all of that over. None of it has to live in your head.

What’s left is the magic, and the magic is taste. Should the letter bounce at all? Is this the moment for it? A model can make motion look natural. It can’t tell you it’s good. I don’t think that part can be written down. Make a list of everything we like and it’s out of date before you finish. Taste keeps moving. That’s the part no model took off us.

These models are really just a store of human memory. Fallible, unpredictable, sometimes astonishing. But it’s more personal than that. What comes back is shaped by you — your words, your tone, the way you ask. No two conversations are the same.

We hand over the logic and keep the magic. Maybe that’s what these tools are really for: they show us what’s human in us. Not a record of where we’ve been. The taste for where to go next.