Welcome to the Era of Personalized Software

SaaS is dead. Long live SaaS.

The French used this phrase for the succession of kings. Le roi est mort, vive le roi! The old monarch dies, the institution endures. The form survives. The substance changes. I’ve been turning this over for weeks because it captures something I can’t say more precisely, the way software is built, distributed, and owned is undergoing a succession of its own. A change.

01 // The Tailor

There is something about going to a tailor. Not the luxury of it, the precision. They measure you. Not the average of a thousand bodies and shapes that came before. The suit fits because it was made for your shoulders, your posture, the way you stand. Nobody else’s.

I’ve been thinking about this because I recently started building a bookmarking tool for myself by myself. I’m a proponent of data governance and sovereignty, I believe your data should live where you decide it lives, not where it’s convenient for someone else’s business model. I used Pocket for years, right up until Mozilla let it die. Tried Raindrop after that. Neither met my criteria. Not because they’re bad products. They’re genuinely good products. For the general case. For 80, maybe 90 percent of what bookmarking needs to be.

But I live in the other 10 percent, my ideas and personal beliefs are something that I hold important and it seeps naturally to software as well.

So I built it. Bookmarks stored in your own AT Protocol repository. Zero-knowledge encryption for the private ones. Your data in your repo, not in someone else’s database. And here’s what makes the protocol beautiful. If I, the builder, go rogue tomorrow, shut everything down, pivot to selling crypto, it doesn’t matter. Your data stays exactly where it is. In your repo. Under your keys. Portable to any client that speaks the same protocol. That’s the difference between building on a platform and building on a protocol. The platform can hold you hostage. The protocol can’t.

And the thing that struck me wasn’t whether I could build it. It was a different question entirely. Why hadn’t I done this before?

The protocols existed. The tools existed. The answer was disarmingly simple, the cost of building something bespoke had never been this low. The friction that used to make just build it yourself a punchline reserved for weeklong hackathons had quietly evaporated.

02 // The Factory

How did we get here? The same way we always do. Through economies of scale. Ironically, capitalism enabled it.

SaaS was the industrialization of software. Just as the factory replaced the workshop, subscription software replaced the custom-built tool. And for what it’s worth, it was good, it worked. Salesforce, Notion, Slack, Jira, these products democratized capabilities that used to require dedicated engineering teams and six-figure budgets. A startup could materialize over a weekend on a stack of SaaS products and a credit card.

But something happened along the way.

Marx described four forms of alienation in industrial labor. Two of them map onto our relationship with SaaS with uncomfortable precision. Written in 1844 about textile mills and iron foundries, and yet if you swap factory for platform and worker for user, the diagnosis reads like it was written last Tuesday.

First, you are alienated from the product of your labor. Your bookmarks live in Pocket’s database. Your documents in Google’s cloud. Your projects in Jira’s servers. You create, organize, curate, and none of it is yours. Think about it for a moment. You spend years building a knowledge base in Notion. Thousands of pages, carefully organized, deeply interlinked. That’s not just data. That’s your externalized thinking. Your second brain, as the productivity crowd likes to call it. And it lives entirely at the mercy of a company you have no relationship with beyond a monthly charge on your credit card. If the service shuts down, pivots, gets acquired, or simply decides to change its API, your work is collateral.

Second, you are alienated from the process of your labor. You don’t shape the tool to match your thinking. You reshape your thinking to match the tool. You learn to organize in Notion’s blocks. You learn to plan in Jira’s sprints. You learn to communicate in Slack’s threads. Slowly, imperceptibly, the tool molds the user.

Walter Benjamin saw the same dynamic in art, decades before software existed.

He called it aura. Ironically, the internet has recently rediscovered the word. Aura is everywhere now, a meme, a vibe, something you farm in video games and measure on TikTok. Benjamin meant something deeper, that quality of uniqueness, of authenticity, that belongs to the original and vanishes in reproduction. A painting has aura. A print does not.

SaaS stripped software of its aura. Every Notion workspace looks the same. Every Trello board. Every Slack channel. The templates differ, the accent colors change, but the container is identical. You’re working inside someone else’s architecture, decorated to feel like yours.

And here’s the thing, generic works. It genuinely does. For the vast majority of what you need, the off-the-rack suit is fine. But the remaining 10-20%? That’s where your actual thinking lives. Where your workflow has those odd edges, those specific needs that no product manager at a SaaS company will ever prioritize, because they serve a market of one.

You.

03 // The Return

History doesn’t repeat, but it rhymes. And this particular rhyme is loud.

Before industrialization, everything was bespoke. The cobbler made your shoes. The carpenter built your table. The tailor cut your cloth. Each item carried the fingerprint of its maker and was shaped for its owner. Then the factory came. Scale won. Cost collapsed. Quality became good enough. The individual yielded to the average.

But look around. Farm-to-table restaurants. Made-to-measure clothing ordered online. Custom furniture making a comeback. Domain after domain, the same pendulum. Bespoke, then mass-produced, then bespoke again. Not regression. Synthesis. The third era carries the economics of the second with the intimacy of the first.

Software is following the exact same arc. And AI is the loom.

What’s new isn’t the desire, the impulse to own your tools is as old as toolmaking itself. What’s new is that building something tailored to your exact needs no longer requires six months and a team of engineers. The barrier didn’t lower gradually. It collapsed.

Taleb would recognize the structural risk of the world we built. When everyone depends on the same five SaaS products, you have a monoculture. Efficient, yes. But fragile in ways we’ve learned to ignore. When Notion goes down, millions freeze. When Figma has an outage, design teams across the globe stop. The same consolidation that made these platforms powerful made them single points of failure.

A world of diverse, personally-built tools is antifragile by nature. Not because each individual tool is better. It might be rougher, less polished, missing features you never needed anyway. But the ecosystem is diverse. Failure stays local. It doesn’t cascade.

04 // The Erosion

Right now, developers are uniquely positioned. We have the context, the instincts, the familiarity with the tools making this possible. We’re the early adopters of our own quiet revolution.

But this window is temporary.

The distinction that matters is between micro and macro complexity. Distributed systems, cryptography, real-time collaboration at scale, these remain genuinely hard. They require deep knowledge and will for the foreseeable future. But the floor is rising. The baseline of what anyone can build, with natural language, with AI assistants, with increasingly sophisticated abstractions, is moving upward at a pace that even the most optimistic predictions from five years ago didn’t anticipate.

What takes a developer a weekend today will take a non-developer a weekend tomorrow. And then an evening. And then an afternoon. The tools don’t care about your credentials. They care about your intent.

Habits are hard to break. The inertia of good enough is powerful. People will keep using Notion, keep filing Jira tickets, keep storing bookmarks in someone else’s database. For a while. But once the process starts, it’s natural. Like erosion. Water finds the cracks. Each small departure, a personal script here, a custom dashboard there, a tool that does exactly one thing exactly right, widens the gap between what generic software offers and what you know is possible.

Until the whole cliff comes rushing down into the sea, making waves and changes along the way.

Benjamin worried about what we lose when everything is reproduced. Marx, about what we lose when we don’t own what we make. Taleb, about what happens when everything depends on the same fragile systems.

Perhaps the era of personalized software answers all three. Or perhaps it just asks the same questions in a language we haven’t fully learned to speak yet.

When building exactly what you need costs almost nothing, what does it mean to keep settling for something that almost fits?

We’ve been wearing off-the-rack software for two decades. Some of us are starting to remember what a tailor feels like.

Further Reading