What I learned by building a project from scratch – Part 2

v1.0 of my camera self-timer
v1.0 of my camera self-timer

This post picks up where What I learned by building a project from scratch – Part 1 left off. In the last post, I had designed and tested my device and I was preparing to build a working prototype.

It looked good on paper

Yeah. I didn’t design it to look like this, but that’s what you learn by actually building something. The original design, for example, had put that big, ugly, black thing on the inside. The big, ugly, black thing is the beeper to indicate that it’s about to take a picture.

The inner workings
The inner workings

You can’t really see it from these photos, but I had reserved space for it on the inside. Well, not for the one in the photo, but for the smaller one I originally spec’d in the design. The bad news for my prototype, however, was that I could not get the part I spec’d. So I learned my next lesson:

You can have it now or you can have it good

Two of the three legs in the project management triangle: Fast, Good, Cheap; pick any two. I picked Fast and Cheap.

I had to decide, did I want it finished soon or looking good. Clearly, I picked the former.

All put together, it worked (quite well, actually), but it’s looks left something to be desired.

If I had it to do over again… I’d probably make the same decision. The goal of this prototype was to test the functionality. I could iterate and find a part that fits (or find more suppliers so as to not end up in the same bind on the next iteration), but I didn’t want to delay field-testing–something for which looks were secondary.

Clearly, if I had different goals for the prototype, I might have made a different decision. For example, if the goal was to impress others and raise funding, I would have approached the appearance of the project differently–learning yet another lesson…

Keep your goals clear and in front of you

That says it all.


The inner workings from the other side

The device worked quite well and I even used it for what it was designed a few times. While that’s an accomplishment in and of itself, the feature of the design that I didn’t (and couldn’t) appreciate until many years later was its durability–the durability of both the design and the implementation, in fact.

I recently found this prototype in a box hidden in the deep recesses of my garage (where things typically go to disappear). I opened it up and it looked like it did when I built it. The relay (shown in the photo above the battery) needed to have its return spring reattached, but other than that, once I added a battery, it worked just like it used to.

Unfortunately, it lasted decades longer than the camera for which it was designed. Nevertheless, the lessons I learned by building it are timeless.

What I learned by building a project from scratch – Part 1

v1.0 of my camera self-timer
v1.0 of my camera self-timer

It might not look impressive, but this device represents a considerable learning experience for me–an experience that I hope I’m able to pass on to my future students. The only problem, which I hope to rectify after the fact, is that I didn’t recognize the lessons I learned at the time and so I was condemned to relearn the several times later.

The project

It started off simple enough. I wanted to build a timer that would wait 10 seconds and then take a picture.  After thinking about the application, it occurred to me that the first picture might not come out well, so I added the ability to select how many photos it would take after waiting the first 10 seconds. Time to complete this step: about an hour.

Before I had even started, I was already learning a valuable, albeit at the time unrecognized, lesson.

Lesson 1 – Feature creep

Was the ability to take multiple pictures after waiting really needed? (Probably not.)

Was the cost of this change factored in the decision? (No, because I could do anything, cost was no object.)

The prototype

So with my [already revised] specification in hand, I set off to build a prototype. Being a hardware project meant collecting the necessary integrated circuits and other components and wiring them together on a breadboard. After designing the circuitry and ironing out the logic and state diagrams, committing all that to the breadboard was straightforward. With care and incremental testing, the design came together rather quickly. Time to complete this step: About a day–and I was about to learn my next lesson…

Lesson 2 – The prototype is not the product

It was very easy to get ahead of myself at this point. I had a working prototype. My design was validated. I was heading for home plate.

Not so fast. I was really just heading for first base. I was nowhere near having something I could put in my camera bag, let alone let anyone else use.

The real prototype

But wait! Didn’t I just finish the prototype? Nope. That was just the breadboard–more of a working demo.


The real prototype had to look like something I could actually use. In this step, I had to package it into something that not only functioned, but it had to function in the real world. I needed to give it the physical design some attention.

While it would be some time before I actually studied user-centered design, looking back, I had the right idea. I knew the audience (me) very well and I knew the application, so I laid out the user interface and set to make it happen. I was about to learn my next lesson…

Lesson 3 – A working demo is not a prototype

My breadboard project was really just a working demo. The prototype (as in a working example of the product in, more-or-less, product form) was another level of complexity.