Name the thing.
It appears on your server

The one most sites are built on. Themes, plugins, and an editor somebody non-technical can be handed.

WordPress with a shop attached: products, a basket, and checkout, without moving to a different platform.

A CMS for sites with a lot of structure and several people editing them, with permissions that go deeper than most.

For sites where the content itself is complicated and needs modelling properly rather than forcing into pages.

Writing, newsletters and paid subscriptions in one place, for a publication rather than a brochure.

Plain files, served fast. Nothing to break into, nothing to patch, and it will still be up in ten years.

Builds a whole site into static files in about a second, then serves it with no database behind it.

Content-heavy sites that ship almost no JavaScript, so they load quickly on a bad connection.

Markdown in, a finished site out. Long-established, and the one most existing blogs were built with.

The language most of the web runs on, with a web server in front of it and the usual extensions present.

The framework most new PHP applications are written in, with its queues and scheduler already wired up.

The framework behind a lot of larger PHP systems, including the parts of Drupal you never see.

React sites rendered on the server, so pages arrive complete instead of assembling themselves after they land.

The same idea for Vue: rendered on the server, quick to first paint, and friendly to search engines.

Python for real applications, with an admin panel you get for free and sensible answers about security.

Ruby on Rails, with the database and background jobs it expects already sitting next to it.

A shop that stands on its own rather than sitting on top of a CMS, with stock and invoicing built in.

For catalogues that have got big: many products, several currencies, and more than one storefront.

A lighter shop for a smaller catalogue, quick to set up and not much to look after afterwards.

What Wikipedia runs on. For documentation a group edits together and needs the history of.

Your own file sync and sharing, so company documents stop living in somebody personal account.

Visitor numbers you own outright, on your machine, without handing your traffic to an ad company.

The web server in front of everything else, handling certificates and pointing requests at the right place.

The long-standing alternative, and the one older applications and their .htaccess files expect to find.

A web page for looking inside your database when you need to check something by hand.

Real inboxes on your own domain, that work in Outlook, Apple Mail and on a phone like any other account.

Somewhere to read and send from a browser, for when you are on a machine that is not yours.

The familiar webmail client, if you would rather have the one people already recognise.

The receipts, password resets and confirmations your software sends, kept apart from your own mail so one cannot spoil the other.

Filtering before anything reaches you, so the inbox is worth opening and nothing important is buried.

The records that decide whether your mail lands in the inbox or the junk folder. Set up with the domain, not left to you.

Addresses like hello@ and billing@ that land wherever you want, without paying for a mailbox each.

Send a newsletter to your own list from your own machine, without a per-subscriber bill.

Catches mail from a site you are still building, so nothing half-finished reaches a real customer.

The fast JavaScript and TypeScript runtime, with its own bundler and package installer built in.

The standard runtime for JavaScript on the server — anything from an API to a Discord bot.

Node with a watcher in front of it: the process restarts itself the moment a file changes.

TypeScript out of the box and permissions on by default, so a script reaches only what you allow.

Scripts, scrapers, data jobs and web apps, with pip and a virtual environment ready to go.

Compiled, single-binary services that start instantly and sit still on very little memory.

For the parts that must not fall over: compiled, memory-safe, and happy under load.

A JVM host for jar-packaged applications and the long tail of software that expects one.

Run .NET applications and services without keeping a Windows machine around to do it.

Built for staying up: thousands of concurrent connections and processes that recover on their own.

The backend half of a Flutter app, hosted next to everything else it talks to.

Lua with an event loop — small, embeddable scripting for bots, game logic and glue.

The one most new applications are written against, and the safest default if nobody has strong feelings.

What WordPress and most older PHP software expect to find, and are happiest sitting next to.

A drop-in replacement for MySQL that stayed open source, and behaves the same from the application side.

A whole database in one file. Nothing to run, nothing to secure, and plenty for a small site.

Storage for records that do not fit neatly into rows and columns, and may never need to.

In-memory cache, queue and session store. The piece that makes everything else feel instant.

The community fork of Redis, for anyone who would rather not depend on the licence change.

A plain, fast cache that does one job. Often what an older application is already asking for.

Counts over very large tables, fast enough that a dashboard answers while you are still looking at it.

For readings with a timestamp on them: temperatures, prices, request rates, anything sampled over time.

Your own Git remote with issues and pull requests, so the code never has to leave your server.

A community-run Git forge — the same job as Gitea, governed independently.

VS Code in a browser tab, running on the machine, so you can edit from any device you own.

Dashboards and alerts over whatever you measure — traffic, revenue, temperature, anything.

Watches your sites and services and tells you the minute one stops answering.

Full-text search and log analysis at the scale where a database query stops being enough.

Typo-tolerant search that answers as fast as somebody types — the search box on your own site.

A queue between your services, so a slow job never blocks the page a customer is waiting on.

A private Maven repository for the packages your own builds publish and consume.

Self-hosted grammar and style checking, with none of the text leaving your machine.

A private pastebin for logs and snippets — a link you can share without a third party holding it.

Your own live video stream and chat, on your own domain, with nobody else placing the ads.

A personal feed reader that keeps up with an industry without an algorithm choosing for you.

A fast reverse tunnel: expose something running behind a home connection at a public address.

Donate idle capacity to protein-folding research when the machine has nothing else to do.

A self-hosted tabletop reference for a group that would rather not depend on a public mirror.

The Minecraft server most people actually run: plugins, and it holds up with a crowd on it.

The game exactly as Mojang ships it, with nothing added and nothing behaving unexpectedly.

For a modpack: hundreds of mods loaded together, which is most of what a private server gets used for.

The other modding platform, for packs and plugins written against it rather than Forge.

Joins several Minecraft servers into one address, so players move between worlds without disconnecting.

A Rust server with your own wipe schedule, rather than somebody else deciding when the map resets.

A persistent ARK map for a tribe, with the rates and rules set the way your group likes them.

A world that stays up between sessions, so progress does not depend on who is online to host it.

A shared world that keeps running when everyone logs off, and is there again the next evening.

Your own competitive server, with your maps, your config and no queue to get into it.

A community server with the maps and rules you want, rather than whatever matchmaking hands you.

Sandbox and game modes, with addons and Lua scripts you control on a machine you control.

A private tactical server for a group that would rather play together than with strangers.

Low-latency voice with no licence counting your users, and it is free software all the way down.

Low-latency voice chat for a community or a team, including the ARM64 build.

A TeamSpeak-compatible server with its own extensions and no per-slot licensing.

A browser panel for administering TeamSpeak servers without a desktop client.

The audio node music bots stream through, so playback stays smooth while the bot does other work.