A year as copy-paste machines

Part 1 of a series on how a studio rebuilds the way it works from the ground up.

There's a moment every studio hits and almost nobody talks about. It's the moment you realize that the way you've always worked, the way that got you here, is quietly the thing holding you back.

For us, it arrived at around 10 PM, mid-copy-paste, somewhere around the hundredth proposal that month.

Let me back up.

Watch this flow grow

The applications were pouring in. A government grant program had opened the floodgates, and our job was to catch every single one of them. So we built a flow to handle it. And I want you to watch this flow grow, because every step felt like a small win the day we added it.

We were on Notion for our CRM, so a Notion form for first contact was a no-brainer. Five minutes of work. Handled, I thought. Someone fills it out, an automatic email fires off with a link to the real intake form. That one lived in Typeform, because nothing on earth lets you click together branching, conditional questions that fast.

Two tools. Both perfect for the job. I felt clever.

Then the form came back, and a human had to read it.

That human was usually me in the beginning. Open the Typeform response. Process it by hand. Build the proposal by hand. Now, these were nearly identical websites: fixed budget, same grant, so every proposal shared the same skeleton and the same total. Only the details moved. So I'd copy the custom parts out of Typeform and paste them into the proposal.

We built that proposal in Figma. Not because Figma is an obvious place to write a proposal (it isn't, and most people would never think to), but because over the years we'd built a proposal template in Figma so good that we could assemble a polished, genuinely beautiful offer in minutes. That template was a real asset. It was also, I'd later realize, one more wall the data had to be carried over by hand.

Win the project? Write the contract. By hand. Its technical annex got copy-pasted out of the proposal. By hand.

Project wraps? Completion certificate, copy-pasted out of the contract. By hand. Again.

Count them with me: Notion, Typeform, human, Figma, human, human. Four tools, and a human wedged into every gap between them, carrying the same data across by hand, one box to the next, over and over.

We tried Zapier. Sometimes it held. Sometimes a record slipped through the crack between two apps and we'd find out about it from the client. The whole machine ran the way duct tape runs: technically holding, audibly straining, with some part of you always braced for the piece about to fall off.

The part that actually got me

Here's the thing, and it's the thing everybody gets wrong: every single one of those decisions had been right.

The Notion form was obvious. Typeform genuinely is the best at what it does. And our Figma template let us turn out proposals that looked like a million bucks in a fraction of the time it would've taken anywhere else. Not one wrong call in the entire chain. And the chain was still strangling us.

That's the trap nobody warns you about. The mess doesn't come from a bad decision. It comes from the sum of a dozen good ones, each made one at a time, each perfectly reasonable on its own. Every tool you add solves a real problem on the day you add it. Nobody ever sits down and decides to build a six-step manual pipeline held together with copy-paste. You arrive at it the way you arrive at most bad places, one sensible step at a time.

The fix I reached for first

So I did what most people do. I tried to make the connections better.

This was right when every studio on earth was discovering AI, and the promise was intoxicating: bolt an AI tool onto your workflow and watch it 10x overnight. So I went looking for the smarter glue. Better automations. An AI that could read the intake and draft the proposal. An AI that could turn the proposal into a contract.

And it helped. A little. A marginal bump, nowhere near the leap everyone was promising.

It took me embarrassingly long to understand why, so let me save you the months. AI is only as good as the data it can reach. Point a brilliant model at four disconnected tools and it can't do much more than a faster copy-paste, because it's working blind. It can't see the client's intake while it writes the contract. It can't pull the proposal total into the certificate. Every tool is a walled garden, and the AI is standing outside every wall.

Scattered data doesn't get smarter when you add AI. It just gets an expensive autocomplete bolted to the side.

The actual question

So that night, mid-paste, I stopped asking how to wire the four tools together better.

And I started asking why there were four tools at all.

Because the real problem was never the connections. It was that the data lived in four places to begin with. Every wall between two tools was a place where a human had to stand and carry something across by hand, and every one of those handoffs was a place where AI couldn't help, time leaked out, and records quietly died in the gap.

What if none of it lived in four places? What if an application simply became data, and the data became a proposal, and the proposal became a contract, and the contract became a certificate, all inside one place? One database. One source of truth that every tool we used sat directly on top of.

Then those 10 PM nights wouldn't get faster. They'd stop existing. Not because the copy-paste got quicker, but because there'd be nothing left to copy and paste.

That question, why are there four tools at all, turned out to be the first pebble. What started as a fix for a copy-paste problem set off an avalanche that ended up reshaping how the entire studio operates, top to bottom. The whole thing took three months to build, not the years you'd probably assume for something that size, and the reason it was even possible is a thread I'll keep pulling on through this series. That's the real story here.

Next time, I'll get specific about what a scattered workflow actually costs you, the part you can measure instead of guess.