The Future of Software Ownership

We are living through the beginning of a correction. The SaaS era — twenty years of renting software we used to own, of paying indefinitely for things that don't improve, of surrendering our data as the price of admission — is cracking under its own contradictions. The question isn't whether the pendulum swings back. It's how far, how fast, and what takes the place of the model that's breaking.

I want to argue something that might sound obvious once you hear it but that most people in the software industry are still not saying plainly: the future of software is ownership, not rental. The future is local-first, not cloud-dependent. And the future is here — running on your laptop, right now, for the people who are paying attention.

How We Got Here#

In the late 1990s and early 2000s, software was a product you bought. You paid for a license, you got a disk (later a download), and the software ran on your hardware. The relationship was transactional: you paid once, you owned the capability. Microsoft Office, Adobe Photoshop, QuickBooks — these were products.

Salesforce changed this. Marc Benioff's insight in 1999 was that enterprise software buyers didn't actually want to install and maintain software — they wanted the capability. So Salesforce offered the capability as a service. No installation, no maintenance, no IT department required. You paid monthly and logged in from a browser.

This was a genuinely better experience for a genuinely painful problem. Enterprise software installation was soul-destroying. The SaaS model won on its merits.

But over the next two decades, the model expanded far beyond the use cases where it made sense. Every tool became a subscription. Every service became a dependency. Every piece of business-critical data migrated from a file on your computer to a server you don't control, in a format you can't read, under terms you can revoke with 30 days' notice.

We didn't notice because the prices seemed reasonable and the tools seemed to work. Then the prices stopped seeming reasonable.

The Reckoning#

The SaaS correction is happening along several vectors simultaneously.

Price inflation. The combination of rising interest rates (eliminating the growth-at-all-costs playbook), market saturation, and consolidation has produced aggressive price increases across the SaaS landscape. Salesforce's per-seat price has increased roughly 60% over five years. HubSpot moved core features to higher-tier plans. The "free tier as acquisition strategy" has been quietly dismantled across dozens of tools.

AI as a wedge. AI capabilities are now genuinely useful. But AI on your own data — fine-tuned, private, local — is often better than AI on a vendor's shared infrastructure. Tools like Cursor, Ollama, and yes, DenchClaw, demonstrate that local AI models can outperform cloud AI for specific tasks while keeping your data private. The AI moment is, paradoxically, an argument for less cloud dependence, not more.

The lock-in realization. After two decades of SaaS migration, businesses are discovering what vendor lock-in actually costs. Not just in money — in flexibility. The ability to move quickly, to switch tools, to integrate freely, to train AI on your own data without sharing it with a competitor's infrastructure.

Regulatory pressure. GDPR, CCPA, and the emerging patchwork of data sovereignty laws are creating compliance costs for cloud-dependent architectures. The safest data architecture from a regulatory standpoint is often the simplest one: data that never leaves your infrastructure.

What Local-First Actually Means#

"Local-first" is a term from the software design community, originating in the excellent 2019 paper by Martin Kleppmann and collaborators. The core idea: make software that works primarily with local data, uses the network for synchronization and collaboration, and never requires the network for core functionality.

The implications are more radical than they first appear.

Local-first software doesn't have a "service" to be discontinued. The software runs whether or not the company that built it exists. Your data lives in files on your machine — files you can copy, back up, inspect, and migrate. There's no monthly fee for the privilege of your own data.

This doesn't mean local-first software can't collaborate or sync. It means the local copy is the source of truth, not the server. Sync is a feature, not a dependency.

For business software specifically, local-first means something concrete: your customer data, pipeline, and institutional knowledge live where you can always access them. Not behind a login that might stop working. Not in a format that requires a vendor's tool to read. In a file, on your machine, in an open format.

DenchClaw is the most direct expression of this idea I know of in the CRM space. Data stored in DuckDB on your own hardware. Open-source MIT license. No per-seat fees. No vendor dependency. This is what software ownership looks like in practice.

The Open-Source Advantage#

Open-source software has been eating proprietary software for twenty years in infrastructure — Linux, PostgreSQL, Redis, Kubernetes. The same shift is now happening in business applications.

The reasons are structural. Open-source software cannot lock you in because the lock requires the vendor to hold the key. When the source code is public, there is no key. Anyone can fork, extend, and maintain the software independently. The community is the vendor.

For enterprises, open-source business applications offer something proprietary SaaS cannot: the ability to inspect what the software actually does. In an era of AI-powered tools that might be training models on your data, or sharing query patterns with third parties, or building user behavior profiles — the ability to audit the code is a meaningful security guarantee, not just a theoretical one.

YC has backed several companies in this space precisely because the model works at scale. DenchClaw is YC S24. Twenty CRM is open-source and growing. Neon, Supabase, Turso — infrastructure companies with open-source cores that capture enterprise value while keeping the data with the customer.

This is the business model of the next era: open at the core, valuable through services and support, but without the hostage-taking of proprietary data formats.

What Ownership Requires of You#

Software ownership is not free. It comes with responsibilities that the SaaS model conveniently abstracts away — and that abstraction is part of what you pay for.

You become responsible for backup. When your data lives on your machine, you need to back it up. This is not complicated (the DenchClaw setup guide covers this), but it requires intention.

You become responsible for updates. Security patches, new features — you apply them when you choose to, which means you have to choose to.

You become responsible for integration. The SaaS ecosystem is built on integrations between cloud services. Local-first software needs to integrate too, and the ecosystem of local-first integrations is less mature than the cloud ecosystem.

These are real costs. They're also a reasonable trade for the benefits: permanent data access, no per-seat fees, no vendor dependency, and the ability to customize the software to your actual workflow rather than the workflow the vendor imagined.

The question isn't whether local-first is perfect. It isn't. The question is whether the tradeoffs of the SaaS model — recurring cost, data dependency, vendor control — are worth the convenience. For more and more businesses, the answer is no.

The Arc of the Correction#

Here's how I expect the next decade to unfold.

Short-term (2026–2028): Local-first wins in technical workflows first. Development tools (Cursor, Zed), data analysis (DuckDB, Motherduck), and CRM for technical teams (DenchClaw). The primary driver is AI — teams that want to run AI on their own data without sharing it with vendors.

Medium-term (2028–2031): Mainstream business adoption of hybrid architectures. Cloud for collaboration and access, local-first for data ownership. The distinction between "cloud CRM" and "local CRM" blurs as sync becomes a first-class feature of local-first tools.

Long-term (2031+): The SaaS model survives but in a narrower form — true multi-user collaboration tools where cloud infrastructure is genuinely necessary, not just convenient. Single-player and small-team tools consolidate around open-source, local-first alternatives.

The trajectory is clear. The question is whether your business is early enough to benefit from the transition or late enough to get dragged through it.

Frequently Asked Questions#

Isn't local-first software less reliable because it depends on my hardware? Hardware reliability has improved dramatically. Modern SSDs have extremely low failure rates, and local-first architectures work well with automated backup strategies (Time Machine, rsync, cloud sync of the database file). The "cloud is more reliable" argument also ignores cloud outages, which affect businesses that have outsourced their uptime to a single vendor.

What about multi-user collaboration — doesn't that require the cloud? Collaboration requires synchronization, which can be done over the network without requiring the cloud as a middleman. CRRDTs (Conflict-free Replicated Data Types) and sync protocols like Automerge enable real-time collaboration on local-first data. This is an active development area.

Is open-source software enterprise-ready? The Linux kernel, PostgreSQL, Kubernetes, and Firefox are all open-source and enterprise-ready. The question is whether a specific piece of open-source software has the support infrastructure, documentation, and stability your organization requires — not whether open-source in general is enterprise-grade.

How does local-first software handle disaster recovery? The same way you handle any local data: with automated backups. DenchClaw's database is a single file that can be backed up with standard tools. Disaster recovery is simpler than cloud systems because there's no infrastructure state to recreate — just restore the file.

Will there be a local-first version of everything eventually? Not everything benefits from local-first. Real-time collaboration tools (video calls, shared documents), global infrastructure services (CDN, email delivery), and tools that require server-side compute (rendering, transcoding) make more sense in the cloud. The move to local-first is about data ownership, not a categorical rejection of networking.

Ready to try DenchClaw? Install in one command: npx denchclaw. Full setup guide →