On Runtime, Apps are a PaaS on a Linux machine of your own. An
App starts the code in /app from its Procfile's web: line, else npm start,
else python3 app.py, keeps it running on port 8080 and serves it over
HTTPS. Because each App is a whole machine, you can also sudo into it,
install system packages and run anything Linux runs.
What the platform does and what you do
The NIST definition of cloud computing describes PaaS as deploying your own applications onto infrastructure you do not manage, built with languages and tools the provider supports. You control the app and its settings. The provider controls the servers, the operating system, storage and the network.
| Layer | You manage it on IaaS | You manage it on PaaS | You manage it on FaaS |
|---|---|---|---|
| Physical servers, networks, storage | No | No | No |
| Operating system and runtime | Yes | No | No |
| Starting, restarting and routing | Yes | No | No |
| A long-running process | Yes | Yes | No, one handler per request |
| Application code | Yes | Yes | Yes |
On infrastructure as a service you rent the machines and run everything on them yourself. On function as a service you hand over a single handler. A PaaS sits between them: a whole app, kept running, with the machine work done for you.
How a PaaS knows what to run
Most platforms read the same signals from the repository:
- A Procfile. One line per process type, such as
web: node server.js. Heroku introduced it, and on Heroku thewebprocess is the only one that receives HTTP traffic from its routers. - The language's own convention.
npm startfor Node.js, arequirements.txtorpyproject.tomlfor Python. - A port in an environment variable. The platform sets
PORTand sends traffic there. - Configuration in the environment. Keys and database URLs come from variables the platform injects, so one build runs in every environment. This is one of the rules of the twelve-factor app.
Run a Procfile on Runtime
This script creates an App, writes a Procfile and one page to /app, restarts
the App's server, and reads the page through a preview.
Terminalapi=https://api.withruntime.com/v2auth="Authorization: Bearer $RUNTIME_API_KEY"put() { curl -sf -X PUT "$api/apps/$app/files?path=$1" -H "$auth" \ -H "Content-Type: application/octet-stream" --data-binary @- > /dev/null; }app=$(curl -sf -X POST "$api/apps" -H "$auth" -H "Content-Type: application/json" -d '{}' | jq -r .id)trap 'curl -sf -X DELETE "$api/apps/$app" -H "$auth" > /dev/null' EXIT# The Procfile names the web process, as on Heroku.echo 'web: python3 -m http.server 8080 --directory /app/public' | put /app/Procfileecho '<h1>Deployed from a Procfile</h1>' | put /app/public/index.htmlcurl -sf -X POST "$api/apps/$app:exec" -H "$auth" -H "Content-Type: application/json" \ -d '{"cmd": "sudo pkill -f runtime-app || true; sudo -E -u runtime runtime-app", "wait": false}' > /dev/nullpreview=$(curl -sf -X POST "$api/sandboxes/$app/previews" -H "$auth" \ -H "Content-Type: application/json" -d '{"port": 8080}')curl -sf --retry 40 --retry-all-errors --retry-delay 1 "$(jq -r .url <<< "$preview")" \ -H "x-runtime-preview-token: $(jq -r .token <<< "$preview")"# <h1>Deployed from a Procfile</h1>When a PaaS fits
A PaaS fits a web app or API that runs all the time and that you would rather not operate: no patching, no process manager, no load balancer to set up. It fits less well when you need a system package the platform does not offer, or when the app is idle most of the day and a running process costs more than a handler that sleeps between requests. For a ready-made image, a container host runs it as it is (deploy a Docker container).
Related
- How to deploy a Node.js app
- What is function as a service (FaaS)?
- What is an OCI image?
- What is serverless computing?
Sources
- NIST SP 800-145, The NIST Definition of Cloud Computing, checked 17 November 2026
- Heroku Dev Center, The Procfile, checked 17 November 2026
- The Twelve-Factor App, checked 17 November 2026
Facts on this page were checked on 17 November 2026.