Selling one-click applications is a proven hosting business: instead of renting bare servers and hoping customers know what to do with them, you offer ready-to-run apps — a wiki, an analytics tool, a media server, a database — that a customer deploys with a click and you provision, isolate, and bill automatically. Docker makes this practical on modest hardware, and a control panel makes it manageable without a DevOps team. This post lays out the business model, the technical pieces it requires, and how the parts fit together.
The model: sell outcomes, not servers
A customer who wants a private wiki does not want a Ubuntu VPS and a weekend of YAML. They want the wiki. The one-click app business sells exactly that gap:
- Higher perceived value than raw hosting — "your own analytics platform, running in a minute" is worth more than "2 GB of RAM and root".
- Lower support burden per customer — a templated, isolated deployment behaves predictably, versus every customer configuring things differently and breaking them uniquely.
- Density economics — because containers share the host kernel and start from a known image, you fit many customers on one server. That density is where the margin lives.
This is modern shared hosting: the customer sees an app, not a server, and you run many of them per machine.
The four technical pieces you need
Turning "run some containers" into "sell isolated apps to strangers" requires four capabilities. Skip any one and the model either does not scale or is not safe.
How the automation actually connects
The chain that turns a sale into a running app looks like this:
- A customer orders a plan through your billing system.
- The billing system calls the panel's API — Panelica exposes provisioning over a REST API, and an External API secured with HMAC-SHA256 signing for exactly this server-to-server use — to create the customer's isolated account.
- The account is created with its resource limits and isolation in place.
- The customer logs in and deploys their app from the template catalog, or the app is provisioned for them automatically as part of the order.
- Webhooks notify your systems of lifecycle events — deployment, suspension, resource thresholds — so billing and monitoring stay in sync.
We cover the event side of this in a companion post on automating container lifecycles with webhooks and the API. For billing specifically, Panelica has a WHMCS module, so orders in a standard hosting-billing platform can drive provisioning directly.
Reseller layers: selling through others
The model extends upward. With role-based access control, you can give resellers their own slice of the platform — they create and manage their customers, under their own brand, without seeing yours or each other's. Panelica's role hierarchy (owner, admin, reseller, user) supports this natively, so "sell one-click apps" can become "let others sell one-click apps and take a margin", without building a second platform.
What to sell first
Start with apps that have obvious standalone value and simple deployment: a self-hosted analytics tool, a wiki, a media server, an automation platform. These are things people actively search to self-host, they deploy cleanly as templates, and they give a customer a reason to pay monthly rather than run it themselves on a Raspberry Pi. Expand the catalog based on what customers ask for.
Frequently asked questions
Is Docker safe enough to sell to untrusted customers?
Not by itself — that is the central caveat. Containers share the host kernel, so a hosting business needs isolation layers around them (per-user accounts, namespaces, kernel slices), or per-customer virtual machines for the highest-risk tenants. Treat Docker as the packaging and deployment mechanism, and the isolation architecture as the security boundary.
How many customers fit on one server?
It depends entirely on the apps' resource appetite — a lightweight RSS reader is a very different footprint from a memory-hungry search engine. Budget by each app's realistic memory needs and enforce limits so your density assumptions hold. We work through the arithmetic in a dedicated capacity post.
Do I need to build the billing integration myself?
Not necessarily. Standard hosting-billing platforms plus a panel with an API and a ready module cover most of it. The provisioning glue is the part to get right; the billing UI is largely solved.
What is the biggest operational risk?
Tenant isolation failures and resource exhaustion — one customer harming another's data or availability. Both are addressed by the same discipline: strong per-customer isolation and kernel-enforced limits, applied automatically to every deployment.
The takeaway
Selling one-click Docker apps is real, modern shared hosting: sell the outcome, run many tenants per server, automate provisioning from billing. It stands on four pillars — a safe template catalog, per-customer resource limits, genuine multi-tenant isolation (Docker alone is not enough), and API-driven provisioning with billing. Panelica provides all four as a single platform, including the reseller layer, so the hard infrastructure is the product you build on rather than the product you build.