The Parrot That Stopped Coming—and the Bird Detection System I Designed to Find It

A small design experiment in observation, hardware, and letting systems collect data and infer solutions.

It Started With a Parrot

For a while, a parrot used to visit my window ledge almost every day. It didn’t scream, destroy things, or behave like a typical bird. It would just sit there and watch me work.

Quietly. Judgmentally. Like a tiny green supervisor.

At some point, it started feeling oddly familiar. Almost intentional. Like some long-lost ancestor checking in to see whether I was actually doing something useful with my life.

And then one day… it stopped coming.

Days passed. Then weeks. The window ledge stayed empty.Which led to the obvious spiral of questions:

• Is it still coming when I’m not around?

• Has it changed its routine?

• Or… worst case?

Instead of overthinking it forever, I did what any reasonable designer would do.I built a system.

My parrot friend

The Question Became a Design Problem

The real problem wasn’t “where is the parrot?”The problem was: I had no way of knowing.

I couldn’t sit at the window all day. And checking randomly was just guessing. What I needed wasn’t more effort — it was continuous observation.

The empty window sill 🙁

So I decided to design a small, always-on bird detection setup using simple hardware and code. Not to obsess over live feeds, but to quietly collect evidence over time.

Also, full honesty: I couldn’t get it to detect parrots specifically (yet). So I made it detect any bird, and I’d review the captures every now and then to see if my friend ever showed up.

The Setup (Nothing Fancy)

The setup was intentionally simple:

• A Raspberry Pi

• A webcam placed on the window ledge

• A lightweight bird detection model

• A small web page to review what was captured

Camera on the window sill

The camera watches the ledge continuously. When the system is confident that a bird is present, it saves a frame and logs the time. No notifications. No alarms. No constant monitoring.

Just… watching.

Designing the Logic Was the Real Work

The hardest part wasn’t the hardware or the code. It was deciding what counts.

Real life is messy:

• Changing sunlight looks like motion

• Leaves move

• Shadows move

• Pigeons behave like pigeons

So the design work went into:

• Filtering false positives

• Setting confidence thresholds

• Adding cooldowns so it doesn’t save 200 near-identical frames

• Deciding what’s useful to look at later

This is where it stopped feeling like a tech project and started feeling like design.

The Interface (Built for Restraint)

I made a simple web interface to review the system:

• Live view of the ledge

• Bird count for the day

• Recent bird captures

• Rough time windows when birds usually appear

The goal wasn’t to create a flashy dashboard. It was to make something I could check occasionally, to see if my dear parrot friend had returned.

The Result (Plot Twist)

The system worked. Beautifully.

It detected birds reliably. Logged them. Showed patterns. Predicted visit windows.

And the result?

Only pigeons! So many pigeons uhhh!

The parrot never showed up.

Which, oddly enough, was still an answer.

What This Taught Me as a Designer

• You don’t need deep coding skills to build meaningful systems

• One simple idea + basic hardware can go a long way

• Most design decisions are about what to ignore

• Real environments are noisy — systems must be forgiving

• Sometimes, the most important outcome is confirming that something isn’t happening (sorry parrot friend)

Manifesting my dear parrot friends return.

And somewhere out there, the parrot is either watching… or has moved on.

In loving memory of my dear parrot friend.