A senior engineer explains why building a simple app to solve a personal problem, like forgetting movie recommendations, is the ultimate developer flex and a critical career skill.

Forgetting Movie Recs? Good. Now Go Build Something.

I remember it clearly. It was 2 AM, and I was staring at a production alert for prod-db-01. The primary read replica was out of sync. A junior engineer had run a manual data migration script earlier that day. He swore up and down he’d used the read-only credentials, but the logs told a different story. The credentials he needed? They were scribbled on a sticky note that was now probably at the bottom of a recycling bin. We’d discussed the new, secure way to pull them from Vault in a stand-up, but he’d “forgotten” the command. That little moment of forgetfulness cost us a 3-hour P1 incident. So when I see a developer post, “My friends kept recommending movies… I kept forgetting them. So I built an app,” I don’t see a trivial solution to a small problem. I see an engineer who gets it.

The “Why”: Your Brain is a CPU, Not a Hard Drive

Let’s get one thing straight. The problem isn’t that you’re forgetful. The problem is you’re treating your brain like a storage device. It’s not. It’s a processor, designed for creative thought, problem-solving, and connecting ideas. Every time you force it to hold a piece of low-value, static information—a movie title, a package name, a restaurant suggestion—you’re consuming precious RAM that could be used for actual work. The root cause of this problem is a workflow failure. You need a trusted, external system to offload this mental clutter.

The goal is to reduce the friction between having a thought and capturing it. If it takes more than two seconds, you’ll default to the worst option: “I’ll remember it later.” You won’t.

The Solutions: From Sticky Notes to Personal APIs

So, how do we fix this? Like any good engineering problem, we have options, ranging from the quick and dirty to the beautifully over-engineered. It all depends on what you’re trying to optimize for: convenience, learning, or control.

Solution 1: The Quick Fix (The Off-the-Shelf Method)

This is the most straightforward path. Use a tool someone else has already built and perfected. We’re talking about apps like Todoist, Apple Notes, Google Keep, or a specific app like Letterboxd for movies. You set up an “Inbox” or a “Movies to Watch” list, and you use the share sheet on your phone to dump recommendations there instantly. It’s fast, reliable, and requires zero maintenance.

Pro Tip: Don’t get paralyzed by choice here. The “best” tool is the one you’ll actually use. Pick one, commit to it for a month, and don’t look back. The friction of choosing a tool is often an excuse to do nothing.

Solution 2: The Permanent Fix (The Engineer’s Method)

This is what our friend on Reddit did, and it’s the path I respect the most. You identify a personal pain point and build your own damn tool. It doesn’t have to be complex. A simple web form that hits a single API endpoint, which then shoves the movie title into a SQLite database or even a Google Sheet, is more than enough.

Why bother? Because it’s not about the app. It’s about the process. You’re turning a mundane problem into a learning opportunity. You can test-drive a new framework (SvelteKit, FastAPI), practice deploying a container to a cheap cloud instance (maybe on dev-utility-vm-01), and build something that is perfectly tailored to your workflow. You control the data, the features, and the entire stack.

Here’s a dead-simple FastAPI endpoint to get you started. This is practically a weekend project.

from fastapi import FastAPI
from pydantic import BaseModel
import sqlite3

# Define the data model for a movie suggestion
class Movie(BaseModel):
    title: str
    recommended_by: str = "Unknown"

app = FastAPI()

# Create a simple endpoint to add a movie
@app.post("/add_movie/")
async def add_movie(movie: Movie):
    conn = sqlite3.connect('movies.db')
    c = conn.cursor()
    c.execute("INSERT INTO movies (title, recommended_by) VALUES (?, ?)", 
              (movie.title, movie.recommended_by))
    conn.commit()
    conn.close()
    return {"message": f"'{movie.title}' added successfully."}

This is simple, but it’s yours. It’s a real-world application, born from a real-world need.

Solution 3: The ‘Nuclear’ Option (The Architect’s Dream)

This is where you take the “Engineer’s Method” and scale it into a full-blown “Personal Knowledge Management” (PKM) or “Second Brain” system. The movie app is no longer a standalone tool; it’s a module in your life’s API. You build a central API gateway for capturing everything—movies, book notes, code snippets, article bookmarks, and random thoughts. Everything gets tagged, categorized, and stored in a proper database like PostgreSQL on prod-personal-db-01.

You then build different clients to interact with it: a web UI, a command-line tool, a mobile app via Shortcuts, maybe even a Slack bot. This is absolutely overkill for just remembering movie titles, but it solves the root problem holistically. You’re not just building an app; you’re building a system for thinking.

Warning: This is a deep, deep rabbit hole. Do not attempt this unless you find the process of building the system itself to be the reward. Otherwise, you’ll spend more time maintaining your system than using it.

Comparison of Solutions

Ultimately, it doesn’t matter if you’re building a system to track movie recommendations or to manage failover for a multi-region database cluster. The mindset is the same: identify a recurring problem, automate the solution, and free up your brain for more important work. Now, if you’ll excuse me, I need to add a movie to my list.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions