S Simplewala

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.

  1. Choose a template. WordPress, Node.js, Python, a standalone database, or a custom Docker image. See the comparison below.
  2. Name it and pick a server. The server must be Active. The name is how the app appears throughout the portal.
  3. 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.
  4. Set environment variables. One KEY=VALUE per line. Each template states which ones it requires.
  5. 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

TemplateUse it forYou 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

SymptomCause
502 Bad GatewayDNS and routing are correct; the app itself is not running.
Certificate warningDNS had not propagated when the certificate was requested. Wait, then retry.
Site can’t be reachedThe A record has not propagated. Nothing has reached your server yet.

Restart, stop, redeploy, remove

ActionWhat happensYour 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.

Next