---
title: Anti-Portfolio
description: The cutting room floor — projects that taught me the most by going wrong, and the lessons I don't want to waste.
section: craft
tags: [failures, anti-portfolio]
genre: reference
stability: stable
lastUpdated: 2026-04-17
url: https://fardiniqbal.com/docs/craft/failures
---


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 [#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 [#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 [#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 [#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 [#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.