Deployment

Mekong hosted deployment lets you upload a prepared archive and keep the app online without leaving your own machine running.

The dashboard keeps the flow simple:

Choose a stack template
Prepare the correct build output
Zip that output
Upload it from /dashboard/deploy
Go live on your Mekong subdomain

Use the pages below based on whether you are shipping a frontend upload or exposing a backend server.

Frontend

Use the dashboard upload flow for built frontend assets or packaged app archives:

Backend

Use a normal Mekong tunnel when the backend is running on your local computer or server:

The dashboard template names map into the deploy runtimes used by the uploader:

static for plain HTML, React, React Vite, and Vue Vite
nextjs for Next.js apps and Next.js API projects
php for PHP app archives

Frontend upload templates

Stack	Template	Upload this
Plain HTML / CSS / JS	`static`	Archive root contains `index.html`
React Classic	`static`	The contents of `build/`
React Vite	`static`	The contents of `dist/`
Vue Vite	`static`	The contents of `dist/`
Next.js app	`nextjs`	Prepared standalone server root
Next.js API project	`nextjs`	Prepared standalone server root
PHP	`php`	Runtime-ready app root with `index.php`

Backend over tunnel

Stack	Run locally	Expose with
Go	`go run main.go`	`mekong 8080`
FastAPI	`uvicorn main:app --port 8000`	`mekong 8000`
PHP / Laravel	`php artisan serve --port=8000`	`mekong 8000`
ASP.NET	`dotnet run`	`mekong 5000`
Spring Boot	`java -jar target/app.jar`	`mekong 8080`
Express / Fastify	`node server.js`	`mekong 3000`

General archive rules

Upload the final built output, not the source repository
Keep the expected entry files at the archive root after unzip
Include runtime dependencies when the selected template needs them
Use the per-stack pages above if you are unsure about folder layout

Backend apps over tunnel

Backend apps are also supported, but they usually use a normal Mekong tunnel instead of the dashboard upload flow.

If your backend listens on a local port, Mekong can expose it from your machine. This includes:

Spring Boot
Go servers
FastAPI
Flask
PHP / Laravel
ASP.NET
Express / Fastify
other HTTP servers that bind to a port

Typical backend flow:

# Start your backend locally
your-backend-command
 
# Expose the local port
mekong 8080

You can also split frontend and backend:

upload the frontend build through /dashboard/deploy
run the backend locally or on your own VM
expose the backend port with Mekong

This gives you a clean split:

Frontend stays online through dashboard deploy
Backend stays live through a normal Mekong tunnel

Dashboard flow

Open /dashboard/deploy
Choose the deployment type
Pick your subdomain
Upload a .zip
Wait for the deployment to become live

CLI flow

Use the CLI when you already have a built output directory:

mekong deploy ./dist
mekong deploy list
mekong deploy stop my-site

The CLI zips the directory, uploads it, and prints the live URL when it is ready.

The CLI is best for static directories like dist/ or build/. For runtime-oriented templates such as Next.js and PHP, package the exact folder structure described in the stack guides before upload.

Public URL

Hosted deployments are served from:

https://<subdomain>.proxy.mekongtunnel.dev

When to use hosted deployment

Use hosted deployment when:

you already have the final output files prepared
you want the site to stay online after your laptop disconnects
you want a simple zip upload flow

Use a normal tunnel when:

you want to expose a local dev server directly
you want requests to hit your machine in real time
you are still in active local development
you are running a backend locally and just want to expose its port

For stack-specific packaging steps, continue into the frontend or backend guides in the sidebar.

How It Works Overview