PreviewRustaBase OSS is in review. Build with managed PostgreSQL, application hosting, edge delivery, and security.Read the product direction

Platform / Application Hosting

Ship every application with a repeatable workflow.

Deploy static sites and supported server applications from GitHub. RustaBase manages releases, previews, build configuration, domains, and monitoring while source builds remain in your repository workflow.

GitHub-native builds Pull-request previews Framework presets Fast rollback
01COMMITGITHUB REPOSITORY02BUILDFRAMEWORK OUTPUT03PREVIEWPULL REQUEST04RELEASEIMMUTABLE VERSION05LIVEHTTPS · DOMAINROLL BACK

Application delivery

From commit to live traffic.

Your repository builds the application. RustaBase receives the release, checks its health and delivers it through a managed HTTPS address.

  1. Source in GitHub

    Choose the repository, production branch and build settings.

  2. Build in your workflow

    GitHub Actions installs dependencies and produces the published output.

  3. Check the new release

    The new copy must become healthy before visitors switch to it.

  4. Deliver and observe

    Serve through HTTPS, inspect traffic and keep a recovery path.

Application delivery

From repository to running release

Connect your repository, configure the build and runtime, review changes, and operate releases from one application page.

GitHub-native deployments

Keep your code, build workflow and build history in your own repository. RustaBase manages the release that visitors use.

  • Connect a public repository or select a private repository through GitHub.
  • Choose a production branch and enable automatic publishing when you need it.
  • Use the console's Redeploy action to start a build without a new commit.
Explore GitHub deployments

Framework presets and build settings

Start with the closest framework preset, then align the settings with your repository. Package static output or a supported server application's built output.

  • Presets for static files, Vite, Astro, Next.js, Nuxt, SvelteKit and TanStack Start.
  • Set the app folder for monorepos, build command and published folder.
  • For supported server presets, configure the runtime start command and compatible build output.
Explore frameworks

Pull-request previews

Review an eligible change on its own address before merging. New commits update the preview for the same pull request.

  • Same-repository pull requests into the production branch create previews.
  • Preview credentials cannot publish production or read production-only settings.
  • Fork pull requests are excluded; preview availability depends on your plan.
Explore previews

Environment settings

Manage configuration outside source code and choose whether a value belongs to production, previews or both.

  • Scope each variable to the environment that needs it.
  • Secret values are encrypted and masked after saving.
  • Redeploy after changes; browser-facing build variables are not private secrets.
Explore environment settings

Domains and managed HTTPS

Give your application a managed address and connect verified custom domains when your plan includes them.

  • Production and previews have separate public hostnames.
  • Follow the console's DNS instructions and verify certificate readiness.
  • Visitor traffic enters through the edge, not an exposed machine address.
Explore domains

Release history and rollback

Follow the source commit, build status and release result. Switch to a retained successful release when you need to recover.

  • Inspect build steps, durations and focused failure details.
  • New releases are health-checked before traffic switches.
  • Rollback uses a retained runnable release, not any entry in older history.
Explore releases and rollback

Per-application firewall

Control unwanted visitor traffic at the RustaBase edge before it reaches your running application.

  • Block individual IP addresses, CIDR ranges and selected countries.
  • Apply per-visitor request limits and bot protection.
  • Keep each application's protection settings separate.
Explore the firewall

Monitoring and troubleshooting

Connect a release's behavior to its traffic and resource usage. Investigate requests and build failures from the application page.

  • Review request and visitor charts alongside application health.
  • Inspect available request logs and error or slow-request filters.
  • Review CPU and memory information when metrics are available.
Explore monitoring

Marketplace starters you own

Start from a template without giving up control of its source. The application is copied into your own GitHub repository.

  • Choose an available starter and customize its content and settings.
  • Build the application in your repository's GitHub Actions workflow.
  • RustaBase receives the packaged output; it does not build the repository.
Explore marketplace templates

Deploy hooks for your workflow

Let a CMS or trusted automation trigger the same redeploy action as the console. Treat the generated hook address as a credential.

  • Trigger the hook with an HTTP POST from a trusted service.
  • The full secret address is shown once; only its hash is stored.
  • Replacing or deleting a hook invalidates its previous address.
Explore deploy hooks

Before the first deployment

A small set of settings. A repeatable release.

Match the application settings to the repository rather than guessing from a framework name. The published folder must contain the static files or supported server output needed to run your application.

Check the build settings guide
Repository
The GitHub repository containing your application source.
Branch
The branch that publishes production. Leave it empty to use the repository default.
App folder
The application directory within the repository, especially for a monorepo.
Build command
The command GitHub runs to generate the application output.
Published folder
The built files, assets and server output, where applicable, that RustaBase should package.
Start command
For supported server presets, the Node or Bun command that starts the packaged application.
Environment
Configuration scoped to production, previews or both. Expose only browser-safe values to frontend bundles.

Your application is not your database.

Application Hosting delivers the experience visitors open. Backend Engine provides PostgreSQL, users, files, APIs and realtime. Connect them through the Project's API address and access rules; use either service independently when that fits your product.

A release rollback is not a data restore.

Switching to a previous application release does not undo external database writes or migrations. Keep changes compatible with your recovery plan, and manage backend backups separately.

Before you ship

Where does my application build?

In your own GitHub Actions workflow. RustaBase receives the packaged result and manages the running release and delivery. Configure any test step you need in the workflow; a successful build is not a substitute for your application's tests.

Can I run a server-rendered framework application?

Supported server presets package GitHub-built output onto a Node or Bun runtime. Select a compatible framework adapter, published folder and start command; a framework name alone does not guarantee every deployment mode works. Static sites can use export or prerendering instead.

Does every pull request get a preview?

Previews apply to eligible same-repository pull requests into the production branch and are subject to plan limits. Fork pull requests are excluded to avoid exposing deployment credentials. Closing or merging the pull request removes its preview.

What happens when a new release fails its health check?

The current release remains in place rather than switching visitors to an unhealthy new copy. Review deployment status and build failure details before trying again.

Can I roll back to any release in the history?

Only a release that is still retained and runnable is eligible. Older deployment history may remain visible after its release has been retired. Check eligibility in Deployments before relying on rollback.

Are custom domains and previews included in every plan?

Availability and limits depend on your workspace and application plan. Check pricing and the application's available settings before choosing your production setup.

How it works

Production and previews stay separate

A production-branch release uses the live deployment path. Pull requests use restricted preview credentials and never publish over production.

  1. 01 / Commit

    Push to GitHub

    Your repository remains the source of code, settings, and build history.

  2. 02 / Build

    Run the framework build

    GitHub Actions installs dependencies, builds the output, and reports each step.

  3. 03 / Release

    Publish an immutable version

    RustaBase keeps the current release available while the next one becomes ready.

  4. 04 / Operate

    Monitor or roll back

    Check health and usage, or return to the previous kept release when needed.

One workspace, every layer

Build your backend. Ship faster. Stay in control.

Start free and add the platform capabilities your product needs as it grows.