Stop Building Todo Apps: Seven Weekend Projects That'll Actually Stretch Your Brain

The Tutorial-to-Todo-List Pipeline

If you're self-taught, you know the loop: finish a tutorial, build a todo app, start another tutorial, feel vaguely stuck. The problem isn't effort — it's that todo apps, blog engines, and weather dashboards all exercise the same narrow band of skills: forms, fetch calls, render a list. You can build fifty of them and never touch networking internals, concurrency, or parsing.

The fix is projects with a specific skill attached. Each of these is scoped to a weekend (roughly 8–12 hours), targets one muscle, and has known pitfalls so you don't burn Sunday night on a rabbit hole.

1. Write a DNS Resolver From Scratch

Skill: Networking. Build a tool that takes "example.com" and returns an IP by speaking raw DNS over UDP — no libraries.

Time: 8–10 hours. Pitfall: DNS messages have a compression scheme in the name fields that trips everyone up. Budget two hours for it. Julia Evans' "implement DNS in a weekend" writeup is the canonical companion.

2. Build a Rate Limiter

Skill: Concurrency. A token bucket or sliding-window limiter, exposed through a tiny HTTP API, hammered by concurrent requests.

Time: 6–8 hours. Pitfall: The naive version passes your tests and falls apart under parallel load. That failure is the lesson — you'll learn why atomic operations and locks exist. Test with a load generator, not curl.

3. Parse a File Format (No Libraries Allowed)

Skill: Parsing. Pick something with a real spec — WAV audio, GIF, even a .ini file — and write a parser that handles it byte by byte.

Time: 6–10 hours depending on format. Pitfall: Don't pick JSON first; it's deceptively gnarly (Unicode escapes, nesting). WAV is a great starter — binary headers, little-endian integers, immediate visual/audio feedback when you get it right.

4. Build a Command-Line Tool That Does One Thing Well

Skill: UX and packaging. Not the logic — the polish. Flags, helpful errors, --help output, exit codes, cross-platform install.

Time: 4–6 hours. Pitfall: Devs skip error handling because "it works on my machine." The entire lesson here is the 20% of edge cases users actually hit: empty input, missing files, bad flags.

5. Recreate grep

Skill: Algorithms in context. Stream a large file line by line and match a pattern — start with plain substrings, then graduate to a hand-rolled regex engine.

Time: 6–8 hours. Pitfall: The regex engine rabbit hole is real. Scope v1 to literals and ./* only. Bonus lesson: benchmark it against real grep and feel humbled.

6. Build a Tiny Key-Value Store With Persistence

Skill: Data structures and durability. An in-memory hash map is trivial; the interesting part is the write-ahead log — append every operation to disk, replay on startup.

Time: 8–12 hours. Pitfall: Corruption. Kill the process mid-write and see what happens. Fixing that (checksums, append-only design) teaches more about databases than any tutorial.

7. Make Something That Talks to Real Hardware

Skill: Debugging at the boundary. Read a sensor with a $10 Raspberry Pi Pico, or even drive keyboard input at the OS level. The point is I/O that doesn't behave like your nice, predictable HTTP APIs.

Time: 6–10 hours including setup frustration. Pitfall: The pitfall is the lesson. Flaky wiring, timing races, drivers — you'll build the patience and systematic-debugging habits that no framework course teaches.

How to Actually Finish One

Three rules. First, define "done" before you start — write it on a sticky note. Second, timebox rabbit holes to 45 minutes; if you're still stuck, simplify the scope instead of grinding. Third, write a short README when you finish, even if nobody reads it. Explaining what you built is where the learning consolidates.

One project per skill beats ten projects of the same skill. Pick the one that scares you a little, block out a weekend, and build the thing the todo app was never going to teach you.