The decision engine for your whole stack — silicon to software.

Run large language models on your own hardware — private, offline-capable, no per-token API bill.

Own your notes as local files instead of renting a cloud workspace.

Self-hosted metrics, logs, and traces without per-host SaaS pricing.

Keep your secrets in a vault you control, not a vendor's cloud.

Privacy-first, cookie-light analytics you can self-host.

Own your team's communication on infrastructure you run.

Break out of closed smart-home ecosystems — run automation locally on hardware you own.

Replace locked-down consumer routers with open firmware and hardware you control.

Host meetings and calls on open, self-hostable platforms instead of a proprietary cloud.

Keep your files in sync on storage you control, not a vendor's cloud.

Back up and organize your photo library on storage you own instead of renting cloud space.

Test and build APIs with clients that keep your collections in files you control.

Raster image editors and digital-painting tools — the software people use to retouch photos, composite images, and create artwork — and the free, open-source alternatives to subscription creative suites.

No-code and low-code platforms that connect apps and services, moving data between them and triggering multi-step automations. Alternatives here let you run those workflows on infrastructure you control.

Desktop container engines and virtualization tools that let developers build, run, and manage containers (and small Kubernetes clusters) on their own machines. Alternatives here run OCI-compatible containers with a Docker-style CLI while keeping the runtime open-source and on hardware you control.

Full document suites for creating and collaborating on word-processing files, spreadsheets, and presentations, often bundled with email and cloud storage. Alternatives here let you edit and co-author documents on desktops you own or servers you control, with open formats and no per-seat subscription.

Spreadsheet-database hybrids for organizing relational data, building internal tools, and running team workflows without code — grid, kanban, calendar, and form views over structured records.

Platforms for hosting Git repositories with pull/merge requests, code review, issue tracking, and CI/CD. Self-hostable git forges let teams keep source code, history, and developer workflows on infrastructure they control.

Tools for planning and tracking work across teams — issues, tasks, sprints, backlogs, Kanban and Scrum boards, roadmaps, and Gantt scheduling — so teams can organize projects, track progress, and coordinate delivery.

Platforms for building subscriber lists, designing and sending email campaigns and newsletters, and tracking engagement — and the free, open-source, self-hostable alternatives that let you own your subscriber data and choose your own sending provider.

Tools for sharing availability and letting others book meetings or appointments without email back-and-forth — booking-link platforms, group meeting-time polls, and appointment systems for service businesses.

Tools that capture, group, and alert on application exceptions and crashes — the first layer of observability most teams adopt, distinct from full infrastructure/APM observability.

Tools that ingest, index, search, and alert on logs and events at scale — the backbone of troubleshooting and security analytics (SIEM), distinct from metrics-first infrastructure monitoring.

Route your traffic through an encrypted tunnel — for privacy from your ISP, safety on public Wi-Fi, or a freer internet. Options run from privacy-first services to your own self-hosted tunnel.

Private, encrypted, or independent email that doesn't scan your inbox to sell ads — from end-to-end encrypted providers to fast standards-based hosts.

The storage layer behind RAG and semantic search — databases that index embeddings and answer similarity queries. A core decision in every AI stack: managed simplicity vs open-source control.

The orchestration layer of an AI app — frameworks (or deliberately none) for chaining model calls, retrieval, tools, and agents. A decision every AI builder revisits as models get more capable.

Domain registrars and web hosts — where your site lives, what it really costs at renewal, and how to move without breaking anything.

Services and methods that get your personal information out of data-broker databases and people-search sites — paid, budget, and fully free routes compared.

Login, single sign-on, and identity-management platforms that handle user authentication, authorization, and access control for apps and APIs.

Shared-inbox and ticketing platforms that turn customer emails, chats, and social messages into tracked support tickets, with routing, macros, SLAs, and a public help center.

Cloud compute and VPS providers — where your servers run, what the bill really looks like, and who gives the most hardware per dollar.

Kubernetes distributions and container platforms — from single-binary clusters to full enterprise platforms, compared on cost, weight, and control.

The models that turn text into vectors for RAG and semantic search — hosted APIs and open models you can run yourself, compared on quality, price, and data control.

PDF editors and document tools — self-hosted, free, and fairly-priced commercial options compared against the subscription heavyweights.

AI pair programmers and autonomous coding agents — the tools that read your repository, write and refactor code, and run commands on your behalf. Compare editor-integrated agents, terminal agents and self-hosted platforms on licence, model choice, whether they can run against a model on your own hardware, and what a month actually costs.

Text-to-speech and voice cloning — hosted APIs billed per character against open models you can run on your own hardware, compared on quality, licence, and what it actually costs at volume.

Tracing, evaluation and cost tracking for LLM applications — hosted platforms compared against tools you can run yourself. What a request actually cost, why an answer was wrong, and whether a prompt change made things better.

The layer between your application and the model providers — routing, failover, caching, virtual keys and spend limits. Hosted control planes compared against gateways you run yourself.

Where you rent the silicon that runs your models — H100 and A100 hours compared across hyperscalers, specialist AI clouds and peer-to-peer marketplaces, on real per-hour price, availability and what it costs to get your data back out.

Continuous integration and delivery — the machinery that builds, tests and ships your code. Billed by the minute, which makes it one of the few developer costs that grows silently with the team.

Schedulers that run data and AI pipelines on a dependency graph, retry the failures and tell you what broke. Managed tiers are priced for enterprises; the engines underneath are free.

Once you have a model, something has to run it and answer requests. Serverless platforms rent the GPU by the second; the open engines let you own the endpoint.

The software that lets a model plan, call tools and act over several steps instead of answering once. The fastest-moving category in AI, and almost entirely open source.

Database, auth, storage and serverless functions in one hosted bundle, so a front-end team can ship without running a backend. The convenience is real; so is the bill when the app succeeds.

Where API keys, database passwords and certificates live, who can read them, and what happens when one leaks. The category that changed most when HashiCorp changed its licence.

Ship code dark, turn it on for 1% of users, roll it back without a deploy. Priced per connection and per user, which is how a simple boolean becomes a five-figure line item.

What users actually do inside the product — funnels, retention, session replay. Billed per tracked user, so the bill grows exactly as fast as the product does.

The search box in your own product: typo tolerance, faceting, ranking and speed. Hosted search bills per thousand requests, which scales with traffic rather than value.

The service that checks your site is up and tells you before your customers do — plus the public status page you point them at when it is not. One of the few categories where the free tiers are genuinely enough for most people.

The software that runs a referral programme — tracking, attribution, payouts and a marketplace of partners. One of the few categories with no credible open-source option, and we say so.

Working out which company is on your site and changing what they see. Built on proprietary IP-to-company data, which is precisely why nothing here can be self-hosted.

Where a team writes down how things work. Priced per seat, so the cost of documenting rises with headcount even though the documents do not.

Single sign-on, MFA and user directories. Billed per monthly active user, which makes success expensive and makes the open options unusually attractive.

Where the numbers live and get queried. Separating storage from compute made these fast and made the bill unpredictable.

The pipe that collects events once and fans them out to every other tool. Billed per event or per tracked user, so it scales with your product's success.

The system of record for customers and deals. The most expensive per-seat software most companies buy, and the category with the deepest lock-in.

The bucket everything else writes to. Storage is cheap and getting the data back out is not — egress is where this category actually bills you.

Charts on top of the warehouse. Priced per viewer, which means the cost of letting people see a number rises with how many people you want to see it.

Legally binding signatures on documents. Priced per envelope or per seat, for what is fundamentally a PDF, an audit trail and a timestamp.

Where teams sketch architecture and run workshops. Per-seat pricing on a canvas most people open twice a month.

The cache in front of your database. The category that proved a licence can be taken away — and, unusually, given back.

Push code, get a running app. You are paying for the part between a container and a URL, and it is a large multiple of the server underneath.

Password resets, receipts, newsletters. Priced per thousand emails for what is, underneath, an SMTP server and a good reputation.

Content as an API, with the front end left to you. Priced per record, per seat and per API call — three meters on the same content.

Interface design, prototyping and diagramming. Priced per editor per month, which is how a design team of six becomes a four-figure annual line.

The software behind an online shop. Hosted platforms take a monthly fee plus a slice of every sale; the open engines take neither.

Drag-and-drop builders for the dashboards and admin screens nobody wants to hand-code. Billed per developer, which punishes exactly the teams getting value.

Someone else runs your database. The convenience is real and so is the markup — and this is the category where licences changed most in the last five years.

Collecting answers from people. Priced per response, so a successful survey costs more than a failed one.

Adapting a base model to your own data. The managed services charge per training token and keep the resulting weights on their platform; the open toolchains produce adapter files you own outright and can run anywhere.

Retrieval-augmented generation — the plumbing that finds the right documents and hands them to a model. The decision is whether retrieval is a managed API you call or a pipeline you own end to end.

How you find out whether a prompt change made things better or worse. Without it, every model upgrade is a guess. The open tools run in CI next to your unit tests; the platforms add a hosted UI and per-seat pricing.

Filters between a model and the people using it — blocking prompt injection, unsafe output, and personal data leaking into logs. Increasingly a compliance requirement rather than a nice-to-have.

Turning audio into text. This is the category where open weights most decisively caught the paid APIs: Whisper-class models run on a laptop and cost nothing per hour, while the incumbents still bill by the minute.

The record of what you trained, on what data, with which hyperparameters, and how it scored. Cheap to add early, painful to reconstruct later, and priced per seat by every managed option.

Extracting structure from PDFs, scans and forms — the unglamorous first step of most RAG pipelines. Cloud OCR bills per page, which turns a one-off corpus ingest into a four-figure invoice surprisingly fast.