Clay Tech

"clay-works make things real"

translated from clazytech.com

A Flawed Prototype Still Beat a Fifty-Fifty Shot at Apple

A Familiar Risk in Development

Honestly, this kind of situation happens all the time in development. Everyone feels the pain of it, but it happens.

You have to do thorough unit testing before moving on to integration testing. That’s common sense. You evaluate with a 3D print before making a machined part. That’s common sense. No self-merging. That’s common sense.

But everyone knows development never goes entirely by the book like that.

Just to be clear about what kind of situation leads to “things not going by the book,” the typical case is a tight schedule. The causes vary — parts arriving late and squeezing the verification schedule after PCB assembly, staff being unavailable because of competing projects and progress stalling, specifications taking too long to settle and prototyping starting late, or the original plan being reckless to begin with. Whatever the cause, there isn’t enough time, and you’re forced into a choice:

“Do we push back the schedule? Or do we just go for it and move into integration testing as is?”

It’s an extremely uncomfortable, critical situation. One that shouldn’t happen.

But anyone who flatly condemns this kind of situation as “insufficient planning” or “poor coordination” probably doesn’t have much development experience. Or maybe they’ve only ever worked in very fortunate environments. I’m sure plenty of developers are nodding along right now, thinking, “yeah, that happens.”

Especially at startups, there’s no shortage of situations where missing a single event — a trade show, a pitch to investors, a demo for a partner — could sink the company on the spot.

There’s a famous episode about this: when Apple’s early product, the Apple II, was being prepared for its product launch, the prototype reportedly had less than a fifty-fifty chance of booting properly right up until the day itself. But they pulled off the demo, and that success connected to the future that followed — the future in which Apple is now among the companies fighting for the top market capitalization in the world.

But reality doesn’t always give you a happy ending like Apple’s. Plenty of cases exist where rushing the schedule led to a painful failure. In fact, those cases are more common.

That’s why I said earlier that developers would nod along in recognition.

If It’s Familiar, Let’s Prepare for It

Not just for integration testing — here I’ll share the key point to keep in mind whenever you push through something that departs from the plan.

Make absolutely sure the people around you understand it.

That might sound obvious, but this is the one point I think matters most.

Make sure people understand the risk

When you push through against the usual process, there’s naturally a chance of failure. Failing this way can end up delaying the overall schedule even more than if you’d honestly followed the original process and slid the schedule step by step. Bugs that get missed because verification wasn’t thorough enough sometimes surface right when shipment is finally happening.

And then there’s the matter of having made that decision with the risk in mind. This isn’t about pinning down whose call it was, like some blame game. There’s no time for that kind of leisurely discussion. Everyone involved — the whole set of stakeholders — needs to properly understand that “we” made the decision to hit the accelerator here.

Thinking “I said it once, so it must have gotten through” or “I wrote it in the documentation, so we’re fine” is dangerously naive. You need to say it over and over. Ideally out loud, in person. You need to repeat it so many times that it sinks into people at the cellular level — to the point where the listener almost mistakes it for a decision they made themselves.

Why does it matter this much? The worst-case scenario is someone saying, “nobody told me that.”

Say, for example, the development team decides in a meeting to go ahead with integration testing, and the scheduling bottleneck turns out to be a demo for a key client that the sales team has lined up. The development team lead obviously treats this as their own responsibility and casually mentions it in a regular meeting between team leads. The sales team lead is there too, but their understanding amounts to something like, “(Okay, whatever, we’re sticking to the schedule, right?)”

Then on the day of the demo, a developer tells a salesperson, “Feature A works, but Feature B doesn’t,” and everything blows up. The salesperson says: “Nobody told me that.” The developer replies, “No, we talked about that risk within the dev team, and it should have been reported at the leads meeting.” The salesperson comes back with something like, “Are you kidding me? If you’d told me, I could’ve pushed the schedule back a week.” There’s no exchange more unproductive than “I said it” versus “I never heard it.” What matters isn’t whose fault it is — it’s making the demo succeed and landing the sale.

Another common pattern is someone saying, “I didn’t realize the risk was that serious.” Whenever departments differ, understanding naturally becomes uneven. That’s only natural, since different departments have different areas of expertise. But when it comes to risk, there needs to be shared understanding across departments.

In general, the people on the front line think most seriously about risk, down to the worst-case scenarios. But managers, having delegated to the front line, tend to view things through somewhat more optimistic glasses. Cross a department boundary, and that optimism grows even stronger — “(somehow it’ll work out in the end).” And by the time you reach the executives overseeing everything, in most cases they’re not even exercising their own imagination: “what you reported to me is all I know.” You can’t really blame them for this. People in that position have to juggle many other projects and issues and take a bird’s-eye view of everything.

I don’t believe a gap like this gets closed by a single meeting or a single report, and I’ve seen, many times, situations where a gap like this created a rift later on that could never be bridged. Many times. Yes — this is an extremely typical mistake that keeps happening over and over in all kinds of places.

The only way to close that gap is to keep telling people. Again and again, as persistently as it takes.


Originally published in Japanese at https://clazytech.com/2021/08/493/. Translated with LLM assistance and reviewed before publication.