Shipping Qija: a whole music platform, solo, in the agentic era

qija.nl is live, and the app is in TestFlight. Qija is a music player that treats the files you actually own as first-class citizens, then wraps them in a social discovery network — follow friends, see what they're playing, swap mixtapes, get nudged toward the gig down the road. It is, by any honest accounting, a lot of software for one person: an iOS app, a macOS app, a watchOS companion, a widget, a Swift backend, a Python enrichment worker, a bespoke architecture library, and a marketing site. I built all of it solo, and I bootstrapped all of it. This post is about how that was even possible — and what it means that it now is.

// what qija actually is

The pitch in one line: one library for your files and every streaming service — with the next album coming from a friend, not an algorithm.

Streaming has flattened how we relate to music. You rent a catalogue, an algorithm decides what's next, and the files you spent twenty years collecting sit in a drawer. Qija refuses that trade. Your local MP3s, FLACs and ALACs are first-class — scanned, matched against MusicBrainz so the metadata is actually correct, and played back natively. Apple Music subscribers can play full albums inline; Deezer gives previews; a self-hosted Navidrome server slots in too. Files and streams live side by side in one library instead of in four apps that don't talk to each other.

On top of that sits the part I care about most — the social layer. You follow friends, you see what they're listening to, you send albums with a message, you build and share mixtapes. There's a home feed of fresh and popular releases seeded from what you and the people you follow actually play. There's a ListenBrainz-style radio that builds from your top tags. There's a venue-events feature that scrapes the Amsterdam concert calendar — Paradiso, Melkweg, Bitterzoet, Tolhuistuin — and tells you when an artist you follow is playing nearby, so a follow can turn into a ticket.

And then the bits that surprised even me to ship as one person:

• A real-time audio visualiser driven by an on-device FFT in Metal.
• On-device genre tagging with a CoreML model and a hand-rolled mel-spectrogram pipeline in Accelerate — your library gets tagged without a round trip to a server.
• Peer-to-peer device sync over MultipeerConnectivity, so your phone quietly pushes music and artwork to your watch over the local network with no prompts and no cloud.
• A watchOS app with its own little architecture, playing local files with no server dependency at all.
• A standalone macOS CD ripper that detects a disc, looks it up by its TOC against MusicBrainz, and rips to tagged AAC.
• Push notifications with custom notification UI, content moderation on every piece of user-submitted text, ten-language localisation, recovery codes gated behind Face ID, GDPR-compliant account lifecycle.

The backend is a Swift 6 service on Hummingbird with strict concurrency throughout, twenty-odd SQLite tables, an actor-based mapping pipeline that resolves messy track names to canonical MusicBrainz IDs with a ten-tier artist-image fallback chain, StoreKit receipt validation, APNs, and a Stripe webhook. A separate Python worker runs metadata enrichment against a 41 GB local MusicBrainz mirror — bios, images, release editions, venue scraping — and is fully disposable: if it falls over, the user notices nothing. Underneath the apps is qija-tca, my own lightweight composable architecture, which I wrote about recently.

Fifty-plus distinct features. Five platforms. Three languages. Roughly a hundred and seventy thousand lines across the repos. One developer.

// why this wasn't possible two years ago

I want to be precise about the claim, because the internet is full of overstatement on this subject. I am not saying an AI built Qija. I am saying that a project of this surface area — this many platforms, this many subsystems, each demanding genuine domain knowledge — was, until very recently, simply out of reach for a solo developer on any sane timeline.

Think about what Qija touches: AVAudioEngine and gapless playback. MusicKit entitlements. CoreML and vDSP. MultipeerConnectivity and Bonjour. WatchConnectivity. DiscRecording. WidgetKit and notification service extensions. Swift 6 strict concurrency and actors on the server. APNs certificate juggling. StoreKit 2 and App Store receipt validation. A Postgres mirror of MusicBrainz. Each one of those is a week of reading docs and fighting edge cases on its own. Stack fifty of them and the rote cost — not the thinking, the typing and the yak-shaving — used to be measured in years. Solo, it was a non-starter. You'd burn out somewhere around the third subsystem.

Agentic coding collapsed that. Not by thinking for me — by removing the keystroke tax between a clear design and working, tested code. The afternoon I'd have spent wiring up a MultipeerConnectivity browser-advertiser handshake from Stack Overflow fragments became twenty minutes of directing an agent against a spec I'd written, with tests as the contract. Multiply that by fifty subsystems and you don't get a 10% speedup — you get a project that fits in one person's life instead of a team's roadmap.

// experience is the multiplier, not the bottleneck

Here's the part the breathless takes miss. Agentic coding didn't make my twenty-five years of experience obsolete. It made it the single most valuable thing I have.

Qija works because someone decided that local files and streams should sit in one library, that the social graph should be seeded from real listens and not a recommendation black box, that the worker should be disposable so a downed Raspberry Pi never touches a user, that the architecture should have zero third-party dependencies so I can hold it in my head and audit it in an afternoon. Those are judgement calls. They came from seventeen years of shipping iOS apps and watching which decisions age well and which become the thing you curse in year three.

An agent will happily build whatever you ask for, including the wrong thing, beautifully. The bottleneck was never the typing — it's knowing what to type. Knowing that strict concurrency will save you from a class of bug before you write it. Knowing that an actor is the right boundary for a rate-limited external API. Knowing when a feature is a tar pit and should be cut. Knowing what "done" looks like, and what "tested" actually means, so the gate that lets you move fast is a real gate and not theatre. The speed is only safe because experience is steering it. Hand the same tools to someone without the scars and you get a fast route to a mess.

That's the combination I sell: the taste and the judgement of a senior engineer, now amplified by a process that turns that judgement into shipped software at a pace that used to require a team.

// the money: bootstrapped, and a paywall that builds a network

Qija is entirely bootstrapped. No investors, no runway, no pressure to manufacture growth. That freedom shaped the product, and it shaped the monetisation, which I think is the most interesting business decision in the whole thing.

The split is simple: everything that costs me a server is behind the paywall, and everything that doesn't is free. The free tier is a genuinely good local music player — scan, match, play, queue, watch app, receive mixtapes. It costs me effectively nothing per user, so it can be free forever and act as the top of the funnel. The moment a feature touches my infrastructure — the social graph, mixtape creation, radio generation, push, device sync, listen history, LLM-generated artist bios — it lives inside Qija+. You're not paying to unlock a music player. You're paying for the cloud bits, and the price (a few euros a month) is framed honestly as exactly that.

Then the mechanic I'm proudest of: the Qija Circle. A Qija+ subscription doesn't just cover you — it comes with up to three invite slots for friends. One person pays; up to four people get the full experience. That does two things at once, and they're both load-bearing.

First, it guarantees a healthy paid ratio. A full circle is one paying user supporting four — a 25% subscription rate baked into the unit economics, not prayed for. I don't need to convert a quarter of my users individually; the product structure converts them in groups.

Second — and this is the bit that makes a social app actually work — every subscriber arrives with friends already on the platform. The number-one reason social products die is the empty room: you sign up, there's no one there, you leave. The circle solves cold-start by construction. The thing you're paying for is a network, so the act of paying brings the network with you. Server costs become a moat that builds the social graph instead of just draining the bank account. Bootstrapped, that's not a nice-to-have — it's the whole survival strategy.

// a genuinely golden age

I've been writing software for twenty-five years and I don't remember being this excited about the act of building. Qija was hard, and it was also the most fun I've had on a project in a decade — the learning curve was relentless and the loop between "I wonder if I could" and "it's running on my phone" got short enough to be addictive. CoreML mel-spectrograms one day, APNs certificate hell the next, a Metal shader the day after. Things I'd have shelved as "too much for a side project" became a single focused afternoon.

For startups and solo developers, this is a genuinely golden age, and I don't say that lightly. The leverage a single experienced engineer now wields is something that, a few years ago, took funding and a team and a year. The ideas that used to die in the "I'd love to but it's six months of work I don't have" graveyard are now shippable. The constraint has moved from can you build it to do you know what to build, and is it any good — which is exactly where the constraint should sit. Distribution and judgement are the scarce things now. The building has become cheap. If you have a backlog of ideas you parked because they were too big to attempt alone, take them back out. The maths has changed.

// if you're building something

Qija is the proof, not the pitch. The pitch is this: I'm a freelance iOS developer in Amsterdam with twenty-five years in software and seventeen building for Apple platforms, and I now ship at a pace that used to take a team — because I've spent the last couple of years building the process, the tooling and the taste to direct AI agents instead of being impressed by them. If you're a startup that needs a senior engineer who can take an idea from sketch to TestFlight without a roadmap full of headcount, or a founder who wants the leverage of agentic development applied by someone who knows where the bodies are buried — let's talk.

And if you just want to listen to your own music with your friends again — Qija's at qija.nl. TestFlight's open. Come build a circle.

— AM, Amsterdam, June 2026