Anti-Portfolio
The cutting room floor — projects that taught me the most by going wrong, and the lessons I don't want to waste.
Most portfolios are highlight reels. This is the cutting room floor — the projects that taught me the most by going wrong. I keep them here because the lessons were expensive and I don't want to waste them.
Showing what didn't work takes more nerve than showing what did.
1. Social Media Scheduler in Rust
Spring 2024
What I tried: Tried to build a social media scheduler in Rust as my first serious project in the language.
Why it failed: Chose Rust because I wanted to learn it, not because the problem needed it. The borrow checker turned a two-week project into two months. The actual problem wanted rapid prototyping, not memory safety.
Lesson: Pick the tool for the problem, not the problem for the tool. Learning a language and shipping a product are different games with different rules.
2. Over-Engineered Personal CRM
Fall 2024
What I tried: Built a contact management system with relationship scoring, interaction logging, and ML-based follow-up suggestions.
Why it failed: Three weeks of architecture for a fifty-row spreadsheet problem. The ML model needed more data than I'd generate in a lifetime. I was solving a problem I didn't have.
Lesson: If a spreadsheet solves it, the spreadsheet is the answer. Complexity is a cost, not a feature.
3. Microservices for a Solo Project
Summer 2023
What I tried: Split a simple CRUD app into four microservices with message queues, an API gateway, and independent deployment pipelines.
Why it failed: Spent more time debugging service-to-service communication than building features. A monolith would have shipped in a weekend. I'd architected for a team that didn't exist.
Lesson: Microservices solve organizational problems, not technical ones. A solo developer with a monolith will outship a solo developer with microservices every single time.
4. Abandoned Open Source Library
Winter 2023
What I tried: Published v0.1 of a React form library that was going to have "better DX than React Hook Form."
Why it failed: Underestimated the sheer surface area of forms. Accessibility alone was a three-month rabbit hole. Once people started using v0.1, backwards compatibility made it impossible to fix the mistakes I'd baked in.
Lesson: The hard part of open source isn't the first version. It's every version after that. Contributing to mature libraries teaches you more than starting your own.
5. Premature Optimization Spiral
Ongoing
What I tried: Multiple projects where I spent days shaving milliseconds off code that was already fast enough. Memoizing components that rendered twice. Caching queries that took three milliseconds.
Why it failed: Optimization feels productive even when it isn't. I was measuring my own cleverness instead of user impact. Not one of these improvements was detectable by the people actually using the software.
Lesson: Profile before you optimize. If the user can't feel the difference, the difference doesn't exist.
The engineers I admire most aren't the ones who never fail. They're the ones who fail clearly enough to learn something.