My Lab Notebook of Side Projects: 7 Wins, 3 Craters, and What Each One Taught Me
Photo: open lab notebook with handwritten notes on desk next to laptop, via thumbs.dreamstime.com
I keep a lab notebook. Not metaphorically — an actual battered Moleskine where every side experiment gets a hypothesis, a date, and eventually a verdict. Flipping back through three years of entries, I counted ten real experiments: seven that taught me something, three that went down in flames. Both buckets paid dividends. Here's the honest scorecard.
The Wins
1. Load-Testing My Home Server Until It Cried
Hypothesis: My Raspberry Pi homelab running Plex and a few services could handle 50 concurrent streams.
Result: It died at 11. But the failure mode was the surprise — it wasn't CPU, it was the SD card's write throughput collapsing under logging. I moved logs to a tmpfs ramdisk and concurrent capacity jumped to 19.
Transferable lesson: When a system falls over, profile before you upgrade. Your bottleneck is rarely the component you're proud of.
2. Building a Toy Database
Hypothesis: I could write a key-value store with a write-ahead log in a weekend.
Result: It took three weekends, and it works — crudely. My Go implementation handles 40k writes/sec to disk with crash recovery. Repo's linked on my projects page.
Transferable lesson: Nothing teaches durability like implementing it. I now review production storage code with questions I never would have known to ask.
3. Caching HTTP Responses at the Edge of My Router
Hypothesis: A tiny caching proxy on my home network would cut median page-load latency by half.
Result: It cut median latency by 62% but only helped 8% of requests, because most traffic was dynamic or already CDN-cached.
Transferable lesson: Median improvements can be meaningless. Always look at what fraction of traffic your optimization actually touches.
4. A Cron Job That Deprecates My Own Code
Hypothesis: A script flagging any repo untouched for 90 days would help me prune my GitHub.
Result: It flagged 41 repos. I archived 38 and felt fantastic. Unexpected bonus: writing the deprecation notices forced me to write real READMEs for the survivors.
Transferable lesson: Maintenance debt is invisible until you measure it. Measure it.
5. Fuzzing My Own CLI Tools
Hypothesis: Go's built-in fuzzing would find bugs in my personal CLI utilities.
Result: Four crashes in twenty minutes, all from unchecked slice indexing on malformed input.
Transferable lesson: Fuzzing is embarrassingly cheap and embarrassingly effective. There's no excuse not to run it on anything that parses input.
6. Tracking My Own Energy Levels Like a Service
Hypothesis: Logging focus, sleep, and coffee daily for 90 days would reveal patterns.
Result: The strongest correlation wasn't coffee. It was meeting density — more than three hours of meetings and my afternoon output cratered regardless of caffeine.
Transferable lesson: Apply your observability skills to yourself. The dashboard you need most might be about your own habits.
7. Rewriting a Python Script in Rust for Spite
Hypothesis: A coworker joked my 45-second report generator was 'a Python problem.' I rewrote it in Rust.
Result: 1.2 seconds. But the real payoff was that Rust's compiler caught a logic bug the Python version had shipped with for a year — a silently truncated aggregation.
Transferable lesson: Sometimes the type system is the code review. Rewriting for speed is fine; rewriting for correctness is better.
The Craters
8. A Distributed Chat App Before I Understood Consensus
I jumped straight into building a multi-node chat system with no grasp of quorum or split-brain. Two nodes happily disagreed about message history for weeks. Shipped: nothing. Lesson: learn the theory before the architecture, not during the outage.
9. Training a Custom Model to Sort My Email
Three weekends of labeling, two of training, one of despair. Accuracy hovered at 71% — worse than the three regexes I already had. Lesson: sometimes the dumb baseline wins, and checking that baseline first is the actual experiment.
10. A Custom Static Site Generator
Before there was a Dipperstein, there was my own SSG, complete with a plugin system nobody needed. I burned a month on YAML parsing edge cases. Lesson: build the thing you're missing, not the thing that's fun to build. Those overlap less than you'd hope.
Why Keep the Notebook At All
The craters are in the notebook with the same ink as the wins, and that's deliberate. An experiment that fails cleanly — hypothesis stated, result measured, lesson extracted — is never a waste. It's only wasted when it fails vaguely, with no hypothesis and no verdict, which describes most 'research' I did before I started writing things down.
Pick one thing on your someday-maybe list. Write the hypothesis down first. Give it a weekend. Whatever happens, you'll have a better entry for your notebook than a screenshot of a half-finished repo.