Glossary
The words you run into when putting a website or a bot online, in plain language
48 terms ·
- .env
.env is a plain text file of NAME=value lines that a program reads at startup to get its settings and secrets.
It is usually loaded by a library such as python-dotenv or dotenv for Node.js, and the file itself goes into .gitignore so tokens never end up in a public repository. A common mistake is forgetting the file when moving to a server, so the program starts with an empty token and crashes. In Netrun you can import the values from a .env file into the Secrets tab, where they are stored encrypted.
- 0.0.0.0
0.0.0.0 is an address that tells a program to accept connections on every network interface of the machine, not just from inside the machine itself.
On your own computer the difference is invisible, but on a server an app bound to 127.0.0.1 cannot be reached from outside, so visitors get an error instead of the site. That is why you switch the address to 0.0.0.0 before publishing, for example `uvicorn main:app --host 0.0.0.0` or `app.listen(port, "0.0.0.0")`. If Netrun sees that an app only listens on localhost, it suggests switching to 0.0.0.0.
- 502 Bad Gateway
502 Bad Gateway is an error shown by an intermediate server when it cannot get a valid response from the application behind it.
Visitor requests usually reach a proxy first, and a 502 means the app behind it did not start, crashed, or listens on the wrong port or address. Start with the logs: the real cause is almost always there, such as a startup error, running out of memory, or binding to localhost. The fix lives in the app, not the browser, so refreshing the page without changes will not help.
- API
An API is a set of rules for how one program can talk to another: which requests to send and which responses to expect.
A bot talks to the Telegram API, a website to its backend’s API, an AI app to a model’s API. Access to someone else’s API is usually granted with a key that you should keep as a secret, and many APIs have a request limit that returns error 429 when exceeded. The address of a specific API function is often called an endpoint.
- Backend
A backend is the part of an application that runs on a server, receiving requests, checking data, talking to the database and sending back responses.
Users never see the backend directly: they reach it through a frontend or, in the case of a bot, through a messenger. Backends are written in Python, Node.js, Go, PHP and other languages, and they need a computer that stays on. If the frontend and backend live at different addresses, the browser may block requests between them, which is a CORS error.
- Bot token
A bot token is a long secret string that lets the messenger know requests really come from your bot.
In Telegram it comes from BotFather and looks like a number, a colon and a run of letters and digits. A wrong or regenerated token produces a 401 Unauthorized error, and a token leaked in public code lets a stranger control your bot. Keep it in an environment variable and regenerate it at the first sign of a leak.
- BotFather
BotFather is Telegram’s official bot for creating new bots, getting their tokens and changing their name, description and commands.
To create a bot, send /newbot to @BotFather, choose a name and a username ending in bot, and you will get a token. You can also regenerate the token there if it leaks; the old one stops working, so replace it everywhere the bot runs. Make sure you are talking to the real @BotFather with the blue check mark, not an impostor.
- Build
A build is the step that turns source code into a ready-to-run form by installing libraries, compiling and bundling files.
For a React or Vue site the build runs `npm run build` and produces a dist or build folder, while Go and Rust builds produce a single executable. If the build fails, the app never starts, so the first error lines in the build log are your main clue. A frequent cause is code that builds on your machine but uses a library missing from the dependency list.
- Container
A container is an isolated box in which a program runs together with its libraries without interfering with other programs on the same server.
A container is created from an image, and anything the program writes inside it disappears when the container is recreated during an update. That is why databases and user uploads live in persistent storage attached to the container. Containers are usually run by Docker, and on hosting platforms this happens without your involvement.
- CORS
CORS is a browser rule that stops a page on one address from reading responses from a server on another address unless that server explicitly allows it.
The error shows up when the frontend and backend live at different addresses and appears in the browser console as a message about Access-Control-Allow-Origin. It is fixed on the backend by allowing the frontend’s address, for example with CORSMiddleware in FastAPI or the cors package in Express. Turning the check off in your own browser is pointless, because your visitors still have it on.
- Cron
Cron is a scheduler that runs commands on a timetable, such as every hour or every day at 9 a.m.
A schedule is written as five fields, minute, hour, day, month and weekday: `0 9 * * *` means "every day at 9:00". Many hosts have no system cron, so the schedule lives inside the app as a loop or a library such as APScheduler or node-cron. Netrun has no built-in scheduler, so there the schedule lives in your code and the app keeps running.
- Database
A database is a program or file where an application keeps records such as users, orders or messages so they can be found and changed quickly.
A small bot or site is often fine with SQLite, which is a single file next to your code, while several servers or heavy load call for PostgreSQL or MySQL. The classic beginner trap is a database that turns up empty after every code update because it lived somewhere files are not kept. Netrun does not offer a managed database: SQLite goes into the /data folder, and PostgreSQL runs as a service in docker-compose or is hosted elsewhere.
- Dependencies
Dependencies are third-party libraries your code cannot run without, listed in a file such as requirements.txt or package.json.
Libraries are already installed on your computer, but a server installs them fresh from the list, so a missing line turns into ModuleNotFoundError or Cannot find module. For Python you can generate the list with `pip freeze > requirements.txt`, then trim it to what your code actually imports. Pin versions, or in six months a newer library release may install and break your code.
- Deploy
Deploying is moving a program from your computer to a place where it runs for other people all the time and opens from a link.
Deploying covers copying code to a server, installing dependencies, building, starting the app and getting an HTTPS address, which takes hours to set up by hand. This is where most mistakes surface: a missing dependency file, the wrong port, a token that only exists on your laptop. In Netrun a deploy is called publishing: you upload code as an archive, a folder, from GitHub or from an AI editor, and the platform handles the rest.
- DNS
DNS is the system that translates a site name such as example.com into the address of the server the browser should connect to.
DNS records are set at your domain registrar: an A record points to an IP address, a CNAME to another name. After a change, the new address spreads across the internet over minutes to a few hours, so the site may open differently for different people in the meantime. Most problems come from a typo in a record or an old record nobody removed.
- Docker
Docker is a program that packages an app with everything it needs into an image and runs it in isolated containers.
Docker’s main benefit is turning "works on my machine" into "works everywhere": the server runs the same image you do. The build is described in a Dockerfile, and several linked containers are described in docker-compose. Many platforms, Netrun included, build and run containers for you, so you do not need to know Docker to publish, but you can bring your own Dockerfile.
- Docker Compose
Docker Compose is a way to describe several linked containers in one file, such as a website, a database and a queue, and start them together with one command.
The file is called docker-compose.yml or compose.yaml, and each service in it gets its own image, variables and data volumes. Services reach each other by name: from the app, the database is at `db`, not localhost. Netrun publishes a docker-compose project as is, and the plan’s memory and CPU are shared among its services.
- Dockerfile
A Dockerfile is a text file with step-by-step instructions for building an app’s image: which base system to use, what to install and which command to run.
The key lines are FROM (base image), COPY (copy your code), RUN (run a command during the build), EXPOSE (the port) and CMD (the start command). You need your own Dockerfile when automatic builds are not enough, for example to get a browser for Selenium or Playwright or a system library. In Netrun, an app with its own Dockerfile gets its port from the first EXPOSE line.
- Domain
A domain is a human-readable site address such as example.com that you buy from a registrar and point at a server.
A domain is paid for a set term, most often a year, and a forgotten renewal can leave a site without its address. On its own a domain shows nothing: to make it open your site, you add a DNS record at the registrar that points to your hosting. On Netrun Pro you can attach your own domains to a project, each with HTTPS.
- Environment variable
An environment variable is a named setting that a program receives from the system at startup instead of keeping it inside its code.
This is how tokens, database passwords and the port number are passed: Python reads them with `os.getenv("BOT_TOKEN")`, Node.js with `process.env.BOT_TOKEN`. It keeps secrets out of your code and lets you change them without touching files. If a variable is missing, the program gets an empty value and often crashes at startup, so check the name letter by letter.
- Frontend
A frontend is the part of an application that a person sees and uses in the browser: pages, buttons and forms.
Frontends are written in HTML, CSS and JavaScript, often with React, Vue or Svelte, and become a set of files after the build. For data they call the backend through an API. If the frontend and backend are published at different addresses, the backend has to allow requests from the frontend’s address or the browser will throw a CORS error.
- Git and GitHub
Git is a program that keeps the history of changes to your code, and GitHub is a website where those histories are stored online and shared.
The basic loop is saving changes with `git commit` and sending them to GitHub with `git push`. Git lets you roll back to a working version when something breaks, and GitHub lets you connect a project to a host without uploading files by hand. Netrun takes code from GitHub but does not update itself on push: you publish a new version from the dashboard.
- Hosting
Hosting is a service that runs your site, bot or app on someone else’s server and keeps it reachable on the internet around the clock.
Hosting comes in very different shapes: shared hosting for PHP sites, a VPS where you configure everything, and app platforms where you just upload code. When choosing, check which languages are supported, whether the project sleeps without visitors, and whether files survive updates. Hosting, a domain and a server are three different things, and you can buy them from different companies.
- HTTPS and SSL certificate
HTTPS is the secure version of the web protocol, in which data between the browser and the server is encrypted, and an SSL certificate proves the site really is who it claims to be.
Without HTTPS, browsers flag a site as not secure, and many services, such as Telegram webhooks, refuse to work over plain HTTP at all. A certificate is issued for a specific domain for a limited time, so it has to be renewed on schedule, usually automatically, for example through Let’s Encrypt. Netrun issues and renews the certificate for you, so the project link opens over HTTPS right away.
- Image
An image is a ready-made snapshot of a program with all its files and libraries, used to start containers.
An image is built from the instructions in a Dockerfile, and one image can start any number of identical containers. An image does not change while it runs: to update the program you build a new one. Ready-made images of databases and popular services are pulled from Docker Hub.
- localhost
localhost is an address that always means "this same computer", so only someone sitting at that computer can open it.
A link like http://localhost:3000 works only for you and is no good for showing a project to a friend. On a server, an app listening on localhost or 127.0.0.1 is unreachable from outside even on the right port, and visitors see an error. To make a site open from the internet, you publish it on a host and bind it to 0.0.0.0.
- Logs
Logs are a running text record of what a program did and which errors it hit while it was working.
Everything a program prints with print or console.log, plus every error message, ends up in the logs, so they are the first place to look when a bot goes silent or a site will not open. Look for the last lines containing Error, Traceback or Exception: they usually name the file and the cause. In Netrun the logs stream live on the project page.
- MCP
MCP (Model Context Protocol) is an open standard that lets AI assistants connect to outside services and take actions in them on your behalf.
Once you add an MCP server to an editor such as Cursor or Claude Code, you ask the assistant in plain words and it calls the service’s functions itself. Access is usually granted with a key, so only connect servers you trust. With Netrun’s MCP server, an assistant can publish a project straight from the editor.
- OOM (out of memory, exit code 137)
OOM (out of memory) is when a program asks for more RAM than it has been given and the system forcibly kills it, often with exit code 137.
In the logs it appears as a bare Killed or OOMKilled with no usual error text, and the app keeps restarting over and over. Typical causes are loading a large neural network or a whole file into memory, a leak inside a loop, and building a heavy frontend. Processing data in chunks, a lighter model or a plan with more memory will help.
- PaaS
PaaS (platform as a service) is hosting where you upload code and the platform takes care of the server, build, startup and HTTPS.
Well-known examples are Heroku, Render and Railway; unlike a VPS, there is no OS to install, no proxy to configure and no updates to track. In exchange you accept the platform’s rules: the app listens on the assigned port, keeps files in the designated place, and direct server access is usually not available. Netrun belongs to this kind of hosting too.
- package.json
package.json is the project file of a JavaScript or TypeScript app that lists its name, its library dependencies and the commands to start and build it.
The `dependencies` section lists the libraries you need, and `scripts` holds commands: `start` to run the app and `build` to build it. Hosts read this file, so if there is no start script they cannot tell what to run. Next to it sits package-lock.json with exact versions, which you should upload with your code, while the node_modules folder should stay behind.
- Persistent storage
Persistent storage is a place on disk where an application’s files survive restarts and code updates instead of being wiped along with the container.
Without it, an SQLite database, uploaded images and any files the program creates on its own vanish on the next publish, which is behind many "everything got reset" complaints. The fix is to write such files only to the mounted folder and point your settings at that path. In Netrun this is the /data folder: whatever the app writes there survives updates, and you can browse and download the files on the Data tab.
- Polling
Polling is a way for a program to keep asking a server whether anything new has appeared, such as new messages for a bot.
Most Telegram bots in tutorials work this way through the getUpdates method: no public address or HTTPS is required, so the bot runs anywhere. But only one copy of the bot can run at a time; a second one gets a 409 Conflict error saying terminated by other getUpdates request. The alternative is a webhook, where Telegram pushes messages to the bot’s address itself.
- Port
A port is a number that tells apart the programs waiting for connections on one computer, for example 80 and 443 for websites or 8080 for an app.
Locally apps often run on 3000, 5000 or 8000, but on a host the platform usually sets the port, and if the app listens on another one, visitors get a 502 error. The safest approach is to read the port from the PORT environment variable and fall back to your own number only when it is empty. Netrun passes the port number to your app in exactly that PORT variable.
- PostgreSQL
PostgreSQL is a popular free database that runs as a separate server program and handles many users at the same time.
You connect to PostgreSQL with an address, a username and a password, usually as one `postgresql://…` string in a DATABASE_URL environment variable. People choose it when SQLite is no longer enough: many writes at once, several copies of the app, or several services sharing the database. The database files must sit in persistent storage, or they will vanish when the container is recreated.
- Repository
A repository is a project folder together with the full history of its changes, tracked by Git and usually stored on a service such as GitHub.
A repository can be public, visible to everyone, or private, visible only to you and the people you invite. Never put tokens or passwords in a public repository: automated scanners find them quickly. Netrun can take code straight from a GitHub repository, private ones included.
- Runtime
A runtime is the environment that executes your code, such as the Python interpreter, the Node.js engine or the Java virtual machine, in a specific version.
Code written for one version may fail on another, for example when a library needs Python 3.10 and the server has 3.8. The version is usually declared in a project file such as `engines` in package.json, `.python-version` or `runtime.txt`. Netrun detects your project’s language automatically from its files.
- Secret
A secret is any value that grants access to something on your behalf, such as a bot token, an API key or a database password.
Secrets are not written into code or committed to a public repository; they are passed to the program through environment variables. If a secret does leak, regenerate it right away with the service that issued it so the old value stops working. In Netrun you set secrets on the Secrets tab, where they are stored encrypted and reach your app as environment variables.
- Server
A server is a computer that stays switched on and connected to the internet so it can run programs for other people.
Your laptop could act as a server, but it sleeps, switches networks and is not reachable from outside, so sites and bots live on rented machines in data centers. You can rent a whole server or a virtual slice of one (a VPS) and set it up yourself, or hand that job to a hosting platform. The key difference for a beginner is who handles updates, security and restarts after a crash.
- Serverless
Serverless is a model in which your code runs as small functions only in response to a request, and the provider looks after the servers between requests.
AWS Lambda, Yandex Cloud Functions and Vercel functions work this way: you pay per call, and nothing runs while idle. As a result a function cannot hold a persistent connection or loop forever, so a polling Telegram bot, background jobs and WebSockets do not fit without a rewrite. The first call after a pause can be slower, which is a cold start.
- Sleeping site
A sleeping site is one that the host shuts down when nobody visits and starts again on the next visit, which makes that first page load slower than usual.
Free plans save resources this way: while nobody is looking, the app uses no memory. For a portfolio or a class project you will barely notice, but anything that must answer instantly around the clock should not sleep. On Netrun a site on the free plan sleeps when idle and wakes up by itself within a few seconds when someone opens the link, and on Pro it never sleeps.
- SPA
An SPA (single-page application) is a site that loads once and then switches screens with JavaScript in the browser instead of requesting new pages from the server.
Apps built with React, Vue and Svelte into a folder with an index.html usually work this way. A typical bug is a 404 when you refresh a page like /about, because no such file exists; the fix is to serve index.html for every path. Search engines see SPAs less clearly, so blogs and landing pages are sometimes built into ready-made HTML pages instead.
- SQLite
SQLite is a database stored entirely in a single file next to your program, with no separate server needed.
People like it for its simplicity: Python can use it without installing any library, and it is usually enough for a bot or a small site. The main publishing problem is that a database file kept in the code folder gets overwritten on every update, taking the data with it. In Netrun you put the SQLite file into the /data folder, which survives code updates.
- Static site
A static site is a website made of ready files such as HTML, CSS, JavaScript and images that the server hands out as they are, with no program building pages on the fly.
Landing pages, portfolios and built React or Vue apps without their own server work this way: after the build you are left with a folder of files. Such a site is fast and rarely breaks, but it cannot store form submissions or passwords by itself, which takes a backend or an external service. If the folder has an index.html, there is usually nothing else to configure.
- Uptime
Uptime is the share of time a site or bot is running and responding, usually given as a percentage per month or per day.
The gaps between percentages are bigger than they look: 99.9% per month means about 43 minutes of downtime, while 99% is more than seven hours. Uptime depends not only on the host but on the app itself, since an unhandled error takes a bot down just as surely as a server failure. If a project crashes, Netrun restarts it automatically and notifies you about long outages.
- VPS
A VPS (virtual private server) is a rented slice of a physical server that behaves like a separate computer with its own operating system and full access for you.
You can install anything on a VPS, but you do it all yourself: log in over SSH, install the language and the database, set up auto-start, a proxy, HTTPS and security updates. A common beginner trap is a bot started in a terminal window that dies as soon as the window closes. A VPS is great when you need full control; if you just want a working project, an app platform is simpler.
- Webhook
A webhook is a way for an external service to send a request to your application’s address on its own as soon as something happens.
Payments, GitHub and Telegram bots in webhook mode work this way: instead of constantly asking "anything new?", the app waits for an incoming request. That requires a public HTTPS address, so a webhook will never reach localhost. If the address changes or the app stops answering, the service usually retries for a while and then stops sending events.
- WebSocket
WebSocket is a persistent two-way connection between a browser and a server that carries messages in both directions without new requests.
Chats, online games, live charts and notifications are built on it, because the server can message the browser at any moment. The connection address starts with ws:// or, over HTTPS, wss://, and a published site needs wss:// or the browser will block it. The connection drops when the server restarts, so the client should know how to reconnect.