Integrations Overview

Skytells integrations connect external services — source control providers, CI/CD systems, and third-party platforms — to a project and its apps. Learn what integrations are, how they work, and which ones are available.

What Are Integrations?

Integrations are authorized connections between a Skytells project and external services. An integration gives an external system — such as GitHub — specific, scoped access to your project's resources. In return, your project can use that service's capabilities: triggering deployments from a push, reading repository contents during a build, or receiving webhook events.

Integrations are configured at the project level. Once a project is connected to an external service, every app inside that project can use it — without each app requiring its own independent authorization.

Integrations are not account-wide API keys or blanket access grants. Each integration is scoped to one project and uses the minimum access required for the features it enables. If you remove an integration, apps in that project lose access to it, but apps in other projects are unaffected.

How Integrations Work

When you enable an integration, Skytells performs an authorization handshake with the external service. For OAuth-based integrations (like GitHub), you are redirected to the provider to grant access and then returned to the Console. Skytells stores the resulting credential securely and uses it on your behalf for project operations.

Once connected, the integration is used automatically. For example, a GitHub integration is invoked on every push to a tracked branch — without you triggering it manually.

Available Integrations

GitHub

Connect a GitHub repository to enable auto-deployments on push, branch-based deployment strategies, and the full CI/CD flow from commit to production. Uses OAuth for authorization.

Git (Generic)

Connect any Git repository over HTTPS — GitLab, Bitbucket, Gitea, or a self-hosted server. Provide credentials and a repository URL. Ideal when your source is not on GitHub.

Additional integrations are added regularly. Check the Project > Integrations page in the Console for the current list of available providers.

Integration Scope: Project vs. App

Understanding the two levels helps you reason about how integrations propagate:

Level	What it controls
Project	Authorization and connection to the external service. Managed from Project > Integrations.
App	How a specific app uses the integration — which repository, which branch, auto-deploy rules. Managed from the individual app's settings.

A project integration is like a key on a shared keyring. Each app can independently decide which lock to use that key for — but they all draw from the same keyring. Revoking the project-level integration removes the key from every app in the project.

Managing Integrations

Navigate to Project > Integrations in the Console to:

View currently active integrations and their authorization status.
Add a new integration.
Re-authorize an expired credential (for example, after an OAuth token is revoked).
Remove an integration and disconnect all apps that rely on it.

Removing an integration immediately stops any automation that depends on it. Auto-deployments stop, and any build that requires repository access will fail. Re-adding the integration and re-authorizing will restore the connection.

Security Considerations

Integration credentials are encrypted at rest and never exposed in logs or the Console UI.
OAuth tokens are stored per-project. One project's token cannot be used by another project.
Use integrations instead of embedding personal access tokens in environment variables whenever possible. Integrations are auditable, scoped, and revocable.

GitHub Integration — full guide to connecting GitHub, enabling CI/CD, and managing auto-deployments.
Enterprise Network — how the project's private network provides a secure boundary for your services.
Environment Variables — manage secrets and configuration that integrations may produce.

How is this guide?