Apps Overview & Architecture
Understand Skytells apps, including standard apps, Compose apps, Drops, and one-click launches from App Catalog.
An app is a deployable unit inside a Skytells project. Apps have their own deployments, domains, environment variables, logs, monitoring, traffic, schedules, and settings.
Every app belongs to one project. The project is the app's ownership and access boundary: project membership determines who can view or manage the app, and the app is grouped with the project's other apps, databases, domains, and shared configuration. An app does not move outside that boundary when it appears in an account-wide view.
Creating an app and running it are separate stages. Creation establishes the app's identity and source configuration, such as its name, source type, repository, and branch. A deployment then prepares the app to run, applies its build configuration, assigns a managed domain when available, and progresses through deployment states such as queued, building, ready, or error. Each later deployment remains attached to the same app and becomes part of its deployment history.
Deployments can begin from several supported entry points: a GitHub push, a pull request preview, a manual action in the Console, an app- or project-level deploy action, or the CLI. Regardless of how a deployment starts, you inspect and operate the result through the app's shared pages.
Workspace Resources can list the app alongside resources from every project you can access, while Workspace Deployments can include its releases in the account-wide timeline. These views make cross-project discovery easier; the app still belongs to its original project and keeps that project's permissions.
App Types
| Type or workflow | Verified definition | Creation path | Management |
|---|---|---|---|
| App | The standard deployable unit in a project | Create an app and configure its source. GitHub sources can use a repository, branch, and automatic deployments. | Standard app overview and operational pages |
| Compose app | An app based on a Compose definition | Create or deploy a Compose app directly | Remains visible with other apps and reuses the standard app overview |
| Drop | An archive-based app deployed from a ZIP file | Create under Project > Drops or use skytells drops deploy | Uses dedicated Drop pages backed by the same operational capabilities as apps |
| App Catalog launch | A one-click creation workflow, not a separate app type | Select a curated Catalog entry and deploy it into a project | The resulting resource is a Compose app using the standard app controls |
App Catalog is a creation workflow rather than a separate app type: Catalog entries launch as Compose apps. Docker images are documented as a creation method on Create an App, not as a separate app architecture here.
Compose Apps
A Compose app is an app created from a Compose definition. It remains visible in the project Apps list and opens the same overview used by other apps.
There are two verified creation paths:
- Create a Compose app directly from the app creation flow.
- Launch a curated entry from App Catalog, which creates and deploys a Compose app in the selected project.
Shared App Controls
Compose apps use the same operational pages as every other app:
- App Overview for current status and primary actions.
- Deployments for stack release history, build output, and redeployment.
- Environment Variables for configuration and secrets referenced by the Compose definition.
- Domains for routing a managed or custom hostname to the public service.
- Logs for diagnosing service startup and dependencies.
- Monitoring, Traffic, Schedules, and Settings for ongoing operation.
Compose uses the shared app overview and controls. Follow the app documentation linked above for domains, environment variables, logs, monitoring, traffic, schedules, and settings.
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
- Drops — deploy a ZIP-based app through a separate menu while retaining app deployments, domains, logs, and monitoring.
- Create an App — follow the Git, Docker, and Compose creation workflows.
- Workspace Resources — find standard apps, Compose apps, Drops, and databases across all accessible projects.
- Workspace Deployments — review app deployment activity across all accessible projects.
- 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?