Applications
An application is whatever you are actually running — a WordPress site, a Node.js API, a Python service, a container you built yourself. Each one runs in its own Docker container on your server, with resource limits, behind the nginx Front Door.
Deploying
Portal → Apps → Deploy New App.
- Choose a template. WordPress, Node.js, Python, a standalone database, or a custom Docker image. See the comparison below.
- Name it and pick a server. The server must be Active. The name is how the app appears throughout the portal.
- Link a domain (optional). Without one the app is reachable at the server IP and
a port; with one it is reachable at
https://yourdomain.com. - Set environment variables. One
KEY=VALUEper line. Each template states which ones it requires. - Deploy.
Deploying pulls the image, applies your environment, starts the container and — if you linked a domain — configures the Front Door route for it. Most templates take one to three minutes; WordPress can take five.
Creating an app before you have anything to deploy
You do not need an image or a repository to create an app. Tick Start empty — deploy later in the wizard and a name and a server are enough.
The app is created, given a port, routed through the Front Door and issued a certificate, and it serves a placeholder page that says it has been launched but nothing has been deployed into it yet. That means you can check the parts that are easy to get wrong — DNS pointing at the right server, the certificate issuing, the domain resolving over HTTPS — before you have an artifact to deploy. Nothing about the route, the port or the certificate changes afterwards, so what you verified is what your app will land on.
The placeholder runs one of two ways, and you can choose:
- Container (the default) — a small nginx container on the app's port.
- Runtime app — an nginx site on the server, with no container.
When you are ready, open the app's Settings tab and fill in what it was created without — a container image and tag for a Docker app, or a repository URL and branch for a git or runtime app — then deploy. That first deployment replaces the placeholder page. Until the app has deployed once you can also change the deployment type between Docker and Runtime app; after that the type is fixed, because the port is already held by whatever is running.
A domain is optional at this stage too. Without one the app still runs, but it has no public address; attaching a domain later configures the Front Door route and requests the certificate at that point.
A WordPress environment, as an example
WORDPRESS_DB_PASSWORD=choose-a-strong-password
WORDPRESS_ADMIN_USER=admin
WORDPRESS_ADMIN_PASS=another-strong-password
WORDPRESS_ADMIN_EMAIL=you@yourbusiness.com Anything genuinely secret is better held in the portal's secrets vault and referenced, rather than typed into a plain environment variable — the vault has version history and an audit log.
Connecting GitHub, GitLab or Azure DevOps
Portal → Connections. Pick a platform and authorise Simplewala. You are sent to the provider's own consent screen, and what comes back is a token held against your account.
The page states the access each platform is asked for before you click, and shows what was
actually granted afterwards — providers sometimes give less than was asked for, and seeing
that at the time is better than finding out from a failed deploy. GitLab and GitHub Enterprise
accept a self-hosted instance URL; it must be https://.
Each connection can be tested against the provider at any time, and disconnected. Disconnecting revokes the token at the provider where it offers a way to, and removes it from Simplewala either way — if the revocation itself fails, the page tells you so you can withdraw the authorisation in the platform's own settings.
Tokens are stored in your secrets vault when you have one, and encrypted on the platform when you do not. The Connections page says which, per connection. Simplewala never shows a token back to you after the connection is made.
Azure DevOps connects through Microsoft Entra ID rather than Azure DevOps' own OAuth apps, which Microsoft has deprecated. You will be asked to sign in with the work or school account that has access to your organisation.
Deploying from a connected repository
Once a platform is connected, open an app → Settings → Connected repository. Pick the account, then the repository. The branch and clone URL fill in from your choice, and Simplewala clones privately using the connection — you do not need to create a deploy key or paste a token.
Tick Deploy automatically when this branch is pushed and Simplewala registers a webhook on the repository. Pushes to the branch the app follows trigger a deployment; pushes to any other branch, and tag pushes, are ignored.
Auto-deploy needs a little more access than listing repositories does, so if your connection was made before you wanted it, the checkbox will say so and ask you to reconnect. Everything else keeps working in the meantime — you can still deploy by hand.
Changing the repository an app deploys from removes the old webhook before adding the new one. If the old one cannot be removed — access was withdrawn, say — the page tells you, so you can delete it in the repository's own settings.
Disconnecting a platform does not delete your apps. They stay exactly as they are, and say that the connection needs restoring before they can clone privately again.
Simplewala deploys what the repository contains, using the app's deployment type. It does not run your CI pipeline — if you build an image in GitHub Actions or Azure Pipelines, push it to a registry and point a Docker app at it instead.
Which template
| Template | Use it for | You provide |
|---|---|---|
| WordPress | Websites, blogs, landing pages, WooCommerce stores — anything a non-developer will maintain. | Database password, admin credentials, admin email. |
| Node.js | Express, Fastify, Next.js and similar. APIs and custom web apps. | A Git repository or image. Your app must listen on PORT. |
| Python | Django, Flask, FastAPI. | A Git repository or image. Your app must listen on PORT. |
| MySQL / PostgreSQL | A database on its own — for an app hosted elsewhere, or for a developer who needs one. | Database name, user, password. |
| Custom Docker | Anything the others do not cover. If it has an image, it runs here. | Image name and any environment the image needs. |
WordPress arrives with WP-CLI, its MySQL database, PHP-FPM tuned for it and an nginx vhost with
SSL support. Log into /wp-admin with the credentials you set and install your theme.
The full WordPress reference is at Docs → WordPress.
Node.js and Python apps are usually better deployed from a repository than from a prebuilt image — a named release per deploy, and rollback by release. See Git apps.
Connecting a domain
Three things have to be true: the domain is verified, the app is running, and DNS points at the server.
1. Point DNS at the server
Type: A
Name: @ Value: your-server-ip TTL: 300
Type: A
Name: www Value: your-server-ip TTL: 300 See A records if that is unfamiliar.
2. Link it in the portal
Apps → your app → Settings, select the domain, save. The platform writes the Front Door route that sends requests for that hostname to the app's container.
3. Issue the certificate
On the domain's detail page, Request SSL Certificate. Let's Encrypt issues it in 30–60 seconds, provided DNS has already propagated — the certificate authority has to reach the domain to validate it, so this step cannot succeed before the A record does.
When it does not work
| Symptom | Cause |
|---|---|
| 502 Bad Gateway | DNS and routing are correct; the app itself is not running. |
| Certificate warning | DNS had not propagated when the certificate was requested. Wait, then retry. |
| Site can’t be reached | The A record has not propagated. Nothing has reached your server yet. |
Restart, stop, redeploy, remove
| Action | What happens | Your data |
|---|---|---|
| Restart | Container stops and starts, 5–15 seconds. The first thing to try when an app is misbehaving. | Untouched. |
| Stop | Container shuts down and stays down until started. Still occupies disk. | Untouched. |
| Redeploy | Pulls the current image (or builds the current commit) and replaces the container. | Volumes are kept — database files and uploads survive. Only the code changes. |
| Remove | Deletes the container and its configuration. | Volumes are kept. Domain and DNS settings are kept. |
Remove deliberately leaves the volumes behind: deleting an app should not be able to delete the database it was talking to. If you want the data gone as well, remove the volume explicitly from Storage.
Every deploy is recorded as a named release, and a release can be rolled back — so the recovery path for a bad deploy is rollback, not a frantic redeploy.
The private container registry
Every account gets a private Docker registry on the infrastructure domain at /v2/,
behind the same certificate as everything else. Push an image to it and deploy from it without the
image ever being public, and without a Docker Hub pull-rate limit on your deployments.
docker login registry.yourdomain.com
docker tag myapp registry.yourdomain.com/myapp:1.4.0
docker push registry.yourdomain.com/myapp:1.4.0 Credentials are in the portal under Registry. Tag retention is configurable — set it, because an untended registry grows until the volume it lives on is full. A push can optionally trigger a redeploy of the apps using that image, which is the shortest CI pipeline available here: build, push, done.