Apps Overview
Apps are the individually deployable services inside a Skytells project — web servers, APIs, workers, schedulers, and Compose-based multi-service workloads, each running as an isolated container.
An app is the core deployable unit in a Skytells project. Every running service in your system — a web frontend, a backend API, a background worker, a cron job — is an app. Apps are isolated containers deployed inside the project's private network and managed independently through their own pipeline.
App Types
Web App
Serves HTTP traffic on a configured port. Skytells provisions a public endpoint through the reverse proxy automatically. Typical use: frontend, server-rendered apps, REST or GraphQL APIs.
API Service
A backend service with a public endpoint by default. Disable public access in the app settings to make it reachable only from sibling services inside the project by service name. Typical use: microservices, internal APIs consumed by other apps in the project.
Worker
A long-running background process with no HTTP interface. The app runs continuously and processes jobs, messages, or events. Typical use: queue consumers, data processing pipelines, event handlers.
Scheduled Job
A task that runs on a defined schedule (cron) and exits when complete. Not a persistent service. Typical use: nightly batch jobs, periodic data exports, scheduled cleanup tasks.
How Apps Fit Into a Project
Every app you create is internet-accessible by default — Skytells provisions a public endpoint through the reverse proxy automatically. At the same time, every app immediately joins the project's private internal network:
- The app can reach sibling apps or project databases using only their service name — no IP, port, or credentials needed for internal traffic.
- The app's internal hostname is its service name (for example,
http://api,http://worker). - You can disable public access on any app to make it reachable only from within the project network.
This architecture means one project can contain a full production stack where each service is independently deployed, scaled, and observed — yet communicates seamlessly with its siblings entirely inside the private network.
What Each App Has
Every app in a project comes with a dedicated set of controls:
Deployment Pipeline
Build, deploy, and rollback controls. Configure auto-deployment on branch push via the GitHub integration. Each deployment is versioned so you can roll back instantly.
Environment Variables
App-scoped variables that override project-level defaults for this specific service. Encrypted at rest, never exposed in logs.
Domains
Assign one or more custom domains to the app. Skytells handles TLS termination and routing via the reverse proxy automatically.
Logs
Real-time and historical stdout/stderr from the running container. Filter by severity or keyword.
Monitoring
Per-app CPU, memory, and network metrics. Use project-wide monitoring to correlate across services.
Settings
App name, instance size, restart policy, health check configuration, and lifecycle operations such as pause, restart, and deletion.
Creating an App
Navigate to Apps
Open the project in the Console and navigate to Project > Apps.
Start a New App
Select New App.
Choose a Deployment Source
Choose the deployment source: GitHub (auto-deploy from a repository), Docker (deploy a Docker image), or Compose (deploy a multi-service Docker Compose stack).
Configure the App
Configure the app: name, build settings (if applicable), port, environment variables, and instance size.
Create the App
Create the app. Skytells builds and deploys it, placing it in the project's private network and assigning it a service name.
The service name for internal communication is derived from the app name you choose. Pick a name that is meaningful as a hostname — for example, api, worker, or scheduler. Service names must be unique within the project.
Connecting an App to a Project Database
Apps in the same project communicate with databases over the private network using connection details injected as environment variables.
Find the Database Connection Details
Open the database in Project > Databases and copy the connection details, or find the auto-injected environment variable name from the database overview.
Open the App
Open the app in Project > Apps.
Confirm the Connection Variable
Navigate to the app's Environment settings and confirm the database connection variable is present. Skytells injects this automatically for databases in the same project.
Restart or Redeploy
Restart or redeploy the app so it establishes the connection at runtime.
Auto-Deployments
When a project is connected to GitHub via the GitHub integration, each app can be configured to deploy automatically on push:
- Connect the app to a repository and select the branch to track.
- Every push to that branch triggers the build and deploy pipeline.
- Pull request previews can be enabled so feature branches get a temporary deployment environment.
Related
- Databases Overview — provision and connect managed databases to your apps.
- Enterprise Network — how private networking works between apps and databases.
- Environment Variables — manage shared and app-specific configuration.
- GitHub Integration — connect a repository for auto-deployments.
How is this guide?
Settings
Configure project-level preferences, rename your project, manage defaults, and perform high-impact lifecycle operations from the Project Settings page.
Create App
Deploy a new app to Skytells — import a Git repository, clone a starter template, deploy a Docker image, or bring a Docker Compose stack.