Deploy from git

Create a project from a GitHub repository and branch, and follow the build-and-deploy lifecycle from the console.

Pick a repo and branch in the console — NevTan builds it, deploys it, and keeps it live.

Deploy

Point NevTan at a repo and branch from the dashboard. From there, four steps take you from repo to running app. You never leave the browser and never touch a terminal — each step below is one screen in the console, and you'll see the next one only after you've made a choice on the current one.

1. 1
   Select a stack

   NevTan auto-detects your framework, or you pick one manually.

   

2. 2
   Connect your repo

   Authorize GitHub or Bitbucket and pick the repository to deploy.

   

3. 3
   Configure compute and region

   Pick a compute tier and region. NevTan shows the estimated cost before you deploy.

   

4. 4
   Build and deploy

   Watch the build in real time. Traffic switches over the moment it's healthy.

   

Follow the build

The console shows live logs for the whole build, and traffic switches over the moment it's healthy — no downtime, and nothing else to watch or poll yourself.

Inside the Configure & deploy step

The deploy wizard tracks your progress across three named steps: Select stack, Connect, and Configure & deploy — the last one is where region, compute, environment variables, and the Dockerfile all live together on one screen.

• Region — pick from the available regions (e.g. NYC, TOR, SFO, LON, FRA, BLR); compute pricing loads once you've picked one, since it can vary by region.
• Compute — required before you can deploy; the sidebar shows "Not selected" in orange until you pick a tier, and Deploy stays disabled with a note ("Select a compute size to enable deploy") until you do.
• Environment variables — add KEY/VALUE pairs with the + button, or use Import from .env · .conf · .ini · .toml · .yaml · .txt to pull them from a file instead of typing each one.
• Upload Configuration Files — a drag-and-drop area for files like .env, application.properties, or app.conf that your build needs alongside your repo.
• Dockerfile — shown inline, already filled in with the auto-generated template for your detected stack, with an Edit button if you want to customise it before the first deploy (not just after — see Dockerfile).

A Deployment summary sidebar tracks Repository, Branch, Framework, Compute, and Region as you fill the form in, and an Estimated cost box shows the monthly compute price plus a reminder that bandwidth and inference are usage-based on top of it.

Supported stacks

NevTan detects your stack by looking at the files in your repo — no config file to write. If your repo already has a Dockerfile, NevTan builds from that instead and skips detection entirely.

• Java builds run on JDK 17 and package your app as a runnable jar — the runtime image is fixed at JDK 17 regardless of what your pom.xml/build.gradle targets.
• Next.js deploys prefer a standalone server.js build if present, otherwise fall back to next start.
• React, Angular, and Vue are static builds — output from build/ or dist/ is served behind nginx, which is why their default port is 80 rather than a dev-server port.
• Node.js startup auto-resolves in order: dist/main.js, dist/index.js, an npm start script, then index.js/server.js/app.js, then your package.json's main field.
• PHP automatically serves from public/ instead of the repo root when it detects Laravel or Symfony (i.e. a composer.json alongside a public/index.php).
• .NET reads the target framework straight out of your project file and matches the SDK/runtime image to it (.NET 6 through 9 are detected explicitly; undetected projects default to .NET 8).

Whatever port your app listens on, add an EXPOSE line to a custom Dockerfile and NevTan will route traffic to it instead of the stack default — see Dockerfile.

Deploying a Java app

1. 1
   Have a pom.xml or build.gradle at the repo root

   A Maven project needs pom.xml; a Gradle project needs build.gradle or build.gradle.kts. Either is enough for NevTan to recognise it as Java — no separate config file needed.
2. 2
   Select Java on the runtime screen

   Auto-detect picks it up from the file above, or choose it manually if you're starting a fresh project.
3. 3
   NevTan builds it

   Maven projects run mvn package -DskipTests -B; Gradle projects run gradle build -x test --no-daemon. Both build on JDK 17.
4. 4
   NevTan runs it

   The built jar runs on a JDK 17 runtime image, listening on port 8080 — this is fixed regardless of the Java version your pom.xml/build.gradle targets.

Deploying a Python app

1. 1
   Have a dependency or entry file at the repo root

   Any of requirements.txt, pyproject.toml, Pipfile, setup.py, main.py, or app.py is enough for NevTan to recognise the repo as Python.
2. 2
   Select Python on the runtime screen

   Auto-detect picks it up, or choose it manually.
3. 3
   Deploy

   The app is built and deployed listening on port 8000 by default.
4. 4
   Need a specific framework command?

   Django, Flask, and FastAPI all work through this same detection — if your app needs a non-default start command (e.g. a specific uvicorn/gunicorn invocation), set it from the redeploy screen. See Environment variables.

Deploying a Next.js app

1. 1
   Have a next.config.* or the next dependency

   A standard create-next-app project already satisfies this.
2. 2
   Select Next.js (or let auto-detect find it)
3. 3
   NevTan builds it

   Dependencies install from whichever lockfile is present (yarn, pnpm, or npm), then next build runs.
4. 4
   NevTan starts it

   A standalone server.js build is preferred if present; otherwise it falls back to next start, then npm start. Runs on port 3000 with NODE_ENV=production set for you.

Deploying a React app

1. 1
   Have react / react-dom / react-scripts / vite as a dependency

   Covers Create React App and Vite-based React projects.
2. 2
   Select React (or let auto-detect find it)
3. 3
   NevTan builds it

   npm install then npm run build — output is read from build/ or dist/, whichever your build produces.
4. 4
   NevTan serves it

   The static build output is served behind nginx on port 80 — there's no Node process running in production, just static files.

Deploying an Angular app

1. 1
   Have angular.json or @angular/core as a dependency
2. 2
   Select Angular (or let auto-detect find it)
3. 3
   NevTan builds it

   Dependencies install with --legacy-peer-deps, then npm run build --if-present runs.
4. 4
   NevTan serves it

   Output is served behind nginx on port 80, with SPA fallback configured so client-side routes reload correctly instead of 404ing.

Deploying a Vue app

1. 1
   Have vue.config.js/.ts or vue / @vue/cli-service as a dependency
2. 2
   Select Vue (or let auto-detect find it)
3. 3
   NevTan builds it

   npm run build runs, with the native build tools Vue's dependency tree sometimes needs already installed in the build image.
4. 4
   NevTan serves it

   Output is served behind nginx on port 80.

Deploying a Node.js app

1. 1
   Have a package.json

   This is the catch-all for any Node backend that isn't Next.js — Express, NestJS, Koa, and similar.
2. 2
   Select Node.js (or let auto-detect find it)
3. 3
   NevTan builds it

   Dependencies install from your lockfile, and npm run build runs if your package.json defines a build script.
4. 4
   NevTan starts it

   Startup resolves in order: dist/main.js, then dist/index.js, then an npm start script (nodemon/ts-node-dev dev-only scripts are skipped), then index.js/server.js/app.js, then your package.json's main field. Listens on port 3000.

Deploying a PHP app

1. 1
   Have composer.json, artisan, or an index.php

   Covers plain PHP as well as Laravel, Symfony, and CodeIgniter.
2. 2
   Select PHP (or let auto-detect find it)
3. 3
   NevTan builds it

   If a composer.json is present, composer install --no-dev runs to pull in dependencies.
4. 4
   NevTan serves it

   Laravel and Symfony projects (a composer.json alongside public/index.php) are automatically served from public/ instead of the repo root. Runs on port 80.

Deploying a .NET app

1. 1
   Have a .csproj, .fsproj, .vbproj, or .sln at the repo root
2. 2
   Select .NET (or let auto-detect find it)
3. 3
   NevTan matches the SDK to your target framework

   .NET 6 through 9 are detected directly from your project file; if none is detected, the build defaults to .NET 8.
4. 4
   NevTan runs it

   Listens on port 8080.