Skip to main content
All pages in this manual

Running your project

Websites and apps

What this page is for: host something other than 6amMart on this server — a static website, a Node.js app, a PHP website, a WordPress site, a Python or Java app, a reverse proxy in front of an app that runs elsewhere, or a website an AI model builds from your description. Each one is a project in the Projects list, with its own menu. Nothing about your 6amMart projects changes when you add one.

You need

  • A web address for it — a name on a domain in your Cloudflare account, or any domain you can point at this server. It is optional when you create the project: give it there and the panel connects it as soon as the project is set up, or leave it empty and connect it afterwards on Domain & SSL.
  • The code: a folder on your computer, a ZIP, or a git repository (an https:// address). WordPress and Create with AI need no code.

The kinds

KindForWhat runsDatabase
Static websiteHTML/CSS/JS, or a React / Vite / Astro site built to filesnginx alone — no processnone
Node.js appNext.js, Nuxt, SvelteKit, Remix, Express, NestJS…one Node.js process (none at all for a static build)None or MariaDB
PHP websiteLaravel, Symfony, CodeIgniter, plain PHPits own PHP-FPM pool, started on demandNone or MariaDB
WordPressa WordPress sitePHP-FPM with a page cache in nginxMariaDB, created for you
Python appDjango, Flask, FastAPI, any WSGI/ASGI appgunicorn or uvicorn in a virtual environment of its ownNone or MariaDB
Java appSpring Boot, Quarkus, Micronaut, any app run from a JARone JVM processNone or MariaDB
Reverse proxyyour domain in front of an app on another port or another servernginx alone — no processnone
Create with AIa website an AI model writes in Next.jslike a Node.js appNone or MariaDB

6amMart shops are one more kind, from the 6amMart addon: the dialog offers it once the addon is active (or included with the server). Until then the dialog does not mention it — the Addons page in the menu is where it is added.

Beside Create with AI the dialog also has New app with AI Coding: a full Next.js and PostgreSQL product, planned with you and built by a coding agent on this server. It makes nothing in the dialog: it opens AI → AI Coding → Start a new app (see AI Coding). Only the server owner sees it.

Each project gets only what its kind needs. A static website has no PHP pool, no process and no database; a PHP website has no Node.js process. Every website runs on the server's own PHP and Node.js unless you choose another version for it — extra versions are optional downloads, see PHP and Node.js versions.

Every project runs as its own Linux account (site-<short id>) in its own folder (/var/www/_sites/<short id>), so one website cannot read another's files, and a Node.js app only ever listens on the server itself — visitors reach it through nginx and Cloudflare, never directly. Its builds, installs and commands are given a temporary folder of their own in that folder, tmp/, instead of the server's shared /tmp, which on most servers is memory and which every account on the server shares. A Java build is given the same folder (Java ignores the usual setting), and so is an SSH sign-in to the website's account. Anything in tmp/ that nothing has read or changed for ten days is removed, as in /tmp itself. The website's PHP sessions, the files you attach in Create with AI and the names that start with a dot are kept.

Create one

  1. Open Projects and press Create a new project. On a server with no project yet the page shows the choices straight away, and New project on Home opens the same dialog.
  2. Choose the kind.
  3. Everything else is on one screen:
  • Name — the label you will recognise it by. The short id it derives is shown under it (kevins-blog): it names the project's account and folder, and never changes.
  • Static, Node.js, PHP, Python and Java: Where is the code?
  • I'll upload it (the default) — the website is made, and you land on Deploys to put its files there: a ZIP, a folder, or a git repository later.
  • Git repository — once the website is made, the Connect git window opens by itself: the repository, how this server reads it (a token or a deploy key) and its branch, then Connect and deploy (see Deploys below). With a web address, it opens over Domain & SSL while the address connects. If you close the dialog while the website is being made, nothing opens by itself: connect the repository on Deploys whenever you like. Connecting a repository is the server owner's, so a reseller's or a user's sign-in sees this answer dimmed, with the reason.
  • A sixpanel.json — Continue opens the screens of Make a website from a sixpanel.json: paste the file, choose it, or read it from a repository. The name, web address, database and runtime come from the file, so this screen stops asking for them (see A setup file in the repository: sixpanel.json).
  • Node.js only: From an npm package — see From an npm package below.
  • Web address — optional. The address the project should answer on, like blog.example.com; leave it empty to add it later on Domain & SSL. The dialog suggests names on the domains this server already uses, and looks the name up as you type — the same check a 6amMart address gets:
  • a Cloudflare account added to the panel holds the domain — nothing to do: the record (always proxied) and HTTPS are automatic;
  • it is on Cloudflare under another account — pick one: paste that account's ID and API token and the panel does the rest, or I'll add the records myself (an A record to this server, orange cloud on);
  • it is not on Cloudflare — the dialog shows the A record to create with your DNS provider;
  • it already points here — HTTPS is set up straight away;
  • a name that sits too deep for Cloudflare's free certificate is refused with the spelling that works, one press to use it.
  • No domain yet? Use a free test address — tick it instead of typing an address, and the website answers on a name like kevins-blog-a1b2.sixpanel.dev with HTTPS in about a minute. The name comes from your AllsWeb plan, so this server must be connected to your AllsWeb account (Settings → AllsWeb account) and have a certificate email (Settings → General); when it cannot be had, the tick is greyed out with the reason. It is the server owner's: a reseller's or a user's website is made with its own domain. See A free test address below for swapping it for your own domain.
  • Node.js, PHP and Create with AI: Database — No database (the default) or MariaDB if the app stores data. You can add one later on the Database page.
  • Node.js, PHP, Python and Java can also take Supabase (this server) — pick the Supabase app when there is more than one; it is dimmed, with the reason, when this server has none yet — or Supabase Cloud: paste the project URL, the publishable key, the secret key and, optionally, the database connection string. Supabase is asked with them before anything is made, and the website gets its Supabase variables from its first build (see Connect a website to Supabase).
  • WordPress: the site title (it follows the name), the administrator username, the administrator email and the language. The username is suggested from your email address — never admin, the first name login bots try; if you type a guessable one, the dialog says so and offers the suggestion with one press. The email is filled in with the one this server has under Settings → General, and the language follows the panel's.
  • Create with AI: describe the website. If no AI provider is set up yet, the dialog says so, with a link to AI → Providers. You can create the project anyway: the description is kept, and Tia starts on it once a provider is added and the site has its address.
  1. Press Create the project. The panel makes the account, the folder and — if you chose one — the database. Then:
  • With a web address, it connects it by itself: the DNS record (always proxied), the HTTPS certificate, and what the kind does once it has an address — WordPress installs itself, and Create with AI starts its first build (Tia's, when a provider is set up; a starter page otherwise). You land on Domain & SSL while it runs.
  • With a web address whose DNS record is yours to make (the domain is not in a Cloudflare account added to the panel), nothing fails: the project is created, Domain & SSL shows the exact record, and the panel looks for it once a minute for seven days — the moment the name answers it gets the certificate and finishes by itself. You do not have to come back for it.
  • With a test address, the panel asks AllsWeb for the name, gets its certificate and serves the website on it; you land on Domain & SSL while it runs. If AllsWeb gives no name at that moment (every test address of your plan is in use, say), the website is still made, and the job's log says why.
  • Without one, you land on the kind's next step: Deploys for code, Domain & SSL for WordPress, or Build with AI.

If another job is running — a backup, an install, an update — the create queues behind it instead of being refused: the dialog says Queued — starts as soon as "…" finishes and follows it when its turn comes. You can close the dialog, or the browser tab: the project is on the Projects page meanwhile, and a web address you gave it is connected as soon as the create finishes — the server starts that itself.

Small jobs do not wait for another website's deploy. While one website deploys, builds or rolls back, up to two small jobs that touch only their own website run beside it: creating a PHP, static, reverse-proxy, Node.js or WordPress website (with a MariaDB database or none), getting a website's HTTPS certificate, saving its Vhost or Web Rules, and a SaaS business's certificate. So a website you create while another website builds is ready in seconds, not after the build. Two jobs of the same website never run at once, and builds still run one at a time.

Everything else still runs alone, and small jobs wait for it: a backup, a restore, an install, any job of a 6amMart project, and the server's own tasks (updates, software, restarts). A create also waits its turn when it deploys straight away, connects Supabase, reads a sixpanel.json, makes a PostgreSQL, MongoDB or SQL Server database, is a Python, Java, Docker or Create-with-AI website, or is made by a hosting account (its limits are applied to the account's other websites too). The dialog names the job it waits for. A waiting job's card on the website's pages names it too ("Waiting for "…" to finish").

A job that runs alone and is pressed while a website deploys — a backup, say — waits for that deploy. Small jobs of other websites pressed after it still run beside the deploy meanwhile; once the deploy ends, the job that runs alone goes next, after the small jobs already running finish, and nothing pressed later goes before it. A backup or a database import keeps running alone: a backup copies every website at once, so a website half made during it would be saved half made, and an import is only started on a free server.

HTTPS needs an email address for its certificate. If this server has none yet, the web address is still saved on the project and the dialog says where to set the email (Settings → General); then press Connect & get HTTPS on Domain & SSL.

If the create does not finish. The create is a job, and a job can stop half-way: the database server was down, the WordPress download was cut, the server restarted under it. The project then shows setup did not finish on Projects, and every one of its pages opens on a red card, The setup of this website did not finish, with the line where it stopped and two buttons:

  • Finish setting up runs the setup again. It makes only what is missing — the account, the folders, the database, the PHP pool, WordPress's files — and changes nothing that is already there: a database the first attempt made, and anything in it, stays. If the project has a web address, it is connected at the end, as a create does. You do not have to delete the project and make it again.
  • View log opens the log of the attempt that stopped.

Until it has finished, Deploys offers no upload: the files would have nowhere to go. A temporary login sees the card without Finish setting up — that button is the owner's.

Projects → the project's card opens its own menu. Only the pages its kind uses are shown.

The menu shows the pages you use every day first: Overview, the kind's own page (WordPress, Build with AI, Docker app or Reverse proxy), Deploys, Domain & SSL, Logs and Settings. Every other page is under More. Press More to open or close it: this browser remembers your choice for every website. The page you are on is always shown: open a page under More from the search, a link or Tia, and More opens to show that page. The search at the top (Ctrl K) finds every page either way.

Static website

  1. Deploys — drop the folder or its ZIP anywhere on the page, or choose Upload a folder (no need to zip it), Upload a ZIP or Connect git.
  2. The panel finds the first index.html and serves that folder. If it guessed wrong, change Document root on Settings.
  3. Domain & SSL → add the address. The site is live on it with HTTPS.

What happens by itself:

  • A single-page app (React Router, Vue Router…) is recognised and every unknown path is answered with index.html; otherwise a 404.html is used for missing pages. Both are on Settings.
  • A source folder with a build script (Vite, Create React App, Astro…) is built on the server, and only the output is published. Its Build variables page gives that build the values it reads, like VITE_API_URL (see Build variables of a static website).
  • Every deploy clears the Cloudflare cache for the site's addresses, with the token of the Cloudflare account that holds them. Empty the cache on Overview does it by hand.

Node.js app

  1. Deploys — drop the folder or ZIP on the page, or connect git. Until the address answers over HTTPS the first version is only read: the panel finds the framework, imports your .env files and waits, and Deploys shows what is left as a checklist — Files read, Environment, Domain. There is nothing to tick: the build waits so that it sees your variables and the address the app runs at.
  2. Environment — the variables your app reads. Any .env, .env.production, .env.local or .env.production.local in your files is imported automatically. Import a .env file takes a pasted or chosen file. A name .env.example lists with no value is shown as optional, on the Environment page ("Listed in .env.example with no value here: … Optional unless your app needs them"), on the Deploys checklist and in the deploy log: many templates leave a line empty on purpose, like INITIAL_PASSWORD= for a random password. Add them puts those names in as rows to fill. Only the names a sixpanel.json lists in env.required stop a deploy.
  3. Domain & SSL — add the address. The moment it answers over HTTPS, the app is built and started by itself; the checklist on Deploys shows the build, and if it fails, where it stopped, with View log and Build again.

Once the address is connected, an upload or a push builds and goes live at once.

From an npm package

A Node.js app that is published to npm already built can be deployed straight from npm. Nothing is built on your server, so a large app that needs gigabytes of memory to build installs in seconds.

  • When you create the website: choose Node.js app, then under Where is the code? choose From an npm package. Type the package's name (my-app or @scope/my-app), the version — latest, a range like ^1.0.0, or an exact version like 1.0.5 — and, for a private package, its access token. The registry is asked before anything is made: a package that is not there, or a token that cannot read it, makes nothing. Then the website's first deploy starts by itself.
  • On an existing Node.js website: Deploys → An npm package → Choose a package. The same dialog also takes another registry (an https:// address) and Deploy new versions by themselves.

Each deploy turns the version into one exact version, the way npm itself picks one, and checks the download against the sha512 the registry publishes. Only then is it unpacked into a new release and its dependencies installed, as the website's own user. Nothing is built: the package's prepare and build scripts never run. Its install scripts (preinstall, install, postinstall) do run, the way npm runs them when it installs a package, and so do the install scripts of its dependencies. It goes live with the same health check as every release, and visitors keep the old version if the new one does not start. Deploys shows each release's exact version ([email protected]), and Make live on an older release puts exactly that version back.

While the website is live, its status card names the version that is live and the newest one on npm — Version ‹live› is live; ‹newest› is on npm. — with a Deploy ‹newest› button. The panel asks the registry at most every five minutes, once for every website that uses the package. Automatic deploys in the same card is off until you turn it on. When it is on, each new version that your version setting accepts is deployed the way a git push is, and a version that failed once is not tried again. A private package's token is kept like a git token: it is never shown again and never written into the website's files. It is kept in the panel's own settings, so every backup that carries them (Everything and Files only) holds it too, encrypted with your backup password, like a git token.

What can read a private package's token. While a deploy installs the package, npm, the package's own install scripts and the install scripts of every one of its dependencies run as the website, with the token in their environment, so any of them can read it. Use a read-only token that can read this one package and nothing else (on npm's own registry, a granular access token with read-only access to that package alone), never your account's publish token. The token is in no other command: the app itself does not get it when it starts.

Automatic deploys try each version once. A version you rolled back from is not deployed again by itself either: it waits until you press Deploy, and the next version the registry publishes is deployed as usual. A deploy from npm that fails, an automatic one too, sends you the same alert as a failed git deploy. When the registry does not answer, the card says so, and the panel waits longer before each new ask: at least 5, 10, 20 and 40 minutes, then an hour, still once for every website that uses the package. Deploy always asks at once.

The package can carry its own sixpanel.json (its start command, health check and variables). Without one, it is started with its own command (the bin named like the package). A package can also be named in a sixpanel.json: see A prebuilt npm package in the sixpanel.json chapter.

A restore, a move and a staging site keep it an npm website. A backup and a move carry the release without its installed dependencies, and a staging site installs its own. So when such a release is put back from a backup, arrives on another server, or becomes a staging site, its dependencies are installed again the way npm installs a package's, as the website's own user. Nothing is built, and it starts with the same command as before. The release keeps its exact version, so the status card and Automatic deploys work as before. A move brings the package, the version it follows, its registry, its token and the Automatic deploys switch with it; on the new server the switch starts deploying new versions once the move has been accepted. A staging site follows the same package, with its Automatic deploys switch off until you turn it on there. To know a release again after a restore or a move, the panel keeps a small .sixpanel-npm.json beside the package with its name, version, sha512 and registry. That file never holds the token.

The panel detects the framework and the package manager (npm, pnpm, yarn or bun) and fills in the install, build and start commands. All three are editable on Settings.

A build that produces only files (a Vite or Create React App site, next export, an Astro static site) is served by nginx with no process running at all.

A build never slows your live sites down, and it finishes on a small server. Every build runs in a compartment of its own. It may use the memory that was free when it started, less a little kept back for your sites and the database, and never the memory the panel keeps for the database (Server → Database), even when more reads free, as it does just after the database restarts. Past that, the kernel moves the build's own memory into swap, never theirs. There is no hard limit that stops the build: past its share it slows down and keeps going. The build runs in a group of its own (sixpanel\x2dbuild.slice), apart from the database and your sites, so it never shares the memory the panel keeps for the database. A website of a limited account builds inside that account's limits, and a reseller's user with no limits of its own inside its reseller's. A build of an account is planned for at most twice its memory limit (three times the server's memory when it has none), never less than 6,400 MB, and may hold no more swap than that. The memory such a build has is its account's, not the server's: what it is planned for above its account's memory limit goes to swap, and when the server does not have that swap free the panel adds it for the build, on its first deploy and on every later one, so the same build ends the same way each time. Only a build that has no swap to go to (the disk has no room for the swap file, or the build has used all the swap it may hold) is ended at its account's limit. The kernel only slows an account down from nine tenths of its memory and never ends anything there, and with no swap a build there is handed very little new memory: about 1 MB a second just over that line, where it is slowed and left to finish, and less than half of that past the half-way point to the limit, where it would sit still until its deadline. After twenty seconds stalled past that point the panel gives the build a hard limit, the kernel ends it within a second, and the job says the build reached its account's memory limit. It also gets CPU and disk time only when your sites are not asking for them. So on a busy server the build is slower, and the sites stay as fast as they were. When the server does not have enough memory and swap for what the build needs, the panel adds swap for that build only and removes it when the build ends. Part of the swap is kept for your sites and the database, because a build pushes some of their memory into swap too (an eighth of the server's memory, 1,024 MB on an 8 GB server), and the swap it adds covers that as well. A build counts only the server's own swap. Swap the panel added for another build is never counted, because it is taken away: a file the panel could not take away yet, or the file of a build that was still running when the panel restarted (the panel stops that build a few seconds after it starts again). The log says how much: added 1280 MB of swap for this build, and then opens the build with one build memory line that names every limit the build has: MemoryHigh, MemoryMax (none, or a limited account's own), the swap file, zswap and the heap. The heap is sized from those same numbers, never above what the build can hold. A Next.js build's static-generation workers do not take the heap setting; Node gives each about half of MemoryHigh. A build that will use swap also turns on the kernel's compressed swap (zswap; a build of a limited account never does, because it cannot use it), which keeps that memory packed in RAM before it goes to the disk. On our test server it made a large build on a small server's memory three times faster. When the build ends, the server's own setting is put back, and a server where you turned zswap on yourself is left as it is. Each build's own memory is remembered (this build used at most … MB), so the next build of that site gets what it needs from the start. A build that was stopped before it finished only ever raises that number, never lowers it: it was stopped before it reached what it needs. Only a build that finished can lower it. A site that has never been built is planned for 6,400 MB, what one large Next.js 16 build takes with room to spare; the swap that covers it is added only when the server is short of it. A number remembered by an older version of the panel counts as what the build took when that build finished (the release it made went live, or a shop's storefront is the build it made); otherwise the build is planned for at least 6,400 MB until a build of it finishes. Measured on our test server: a fresh Next.js app builds in under a minute on one core with 675 MB, and a large Next.js site with 3,000 pages, which needs 3.7 GB, finishes on a server with 4 GB of memory while that server's sites keep their memory. It takes about ten minutes there instead of four.

A very large Next.js build: build it in two steps. Next.js 16 can split one build into next build --experimental-build-mode=compile and then next build --experimental-build-mode=generate. Measured on our test server on a site of 407 pages: one next build held 3.9 GB at its peak, the two steps 3.4 GB and 1.2 GB, and they made the same site (the same routes, pages and files). When a build comes close to what your server can give it, put the two steps in the build command (Settings, or build.command in sixpanel.json). The panel runs your build command exactly as you wrote it and never changes it for you. The mode is marked experimental by Next.js.

Busy sites: run more than one copy. A Node.js app answers with one processor core. A Next.js site measured on an 8-core server answered 100 visitors a second in 26 ms (95 in 100 of them) and 200 a second in 4.7 seconds, with seven cores idle. Settings → Advanced → Processes runs several copies of the app on the website's port, and the server shares its visitors out between them: Auto runs one a core and one for every 512 MB of the memory limit, at most 8, each with its share of that limit (a copy holds more than its heap, so fewer, larger copies stay inside the limit); or pick a number. "processes": "auto" under node in sixpanel.json does the same. Keep 1 for an app that keeps sessions, websockets or timers in its own memory, since each copy has memory of its own; Next.js keeps none of those itself. It needs Node.js 22.12 or newer.

A crowd costs one render: the page cache. Settings → Advanced → Page cache keeps a page for 10 seconds and gives it to the next visitors who carry no cookie, so a hundred visitors who arrive in the same second are one render, not a hundred. Only a page your app itself marks public (Next.js does for a prerendered page) is kept, never one that sets a cookie, and a visitor who is signed in — who carries a cookie — always gets their own page. When the kept page is out of date, one visitor's request renders it again while the others get the previous copy for that moment. A page your app does not let be kept (a sign-in page, no-store, private) never makes visitors wait for each other: once it has answered that way, the next ten seconds of visitors to that address go straight to the app (X-Cache: PASS). Each deploy empties it. A search engine, a link preview or an AI crawler that Next.js answers with other HTML than a browser (its own list of such crawlers — Googlebot, Bingbot, facebookexternalhit and the rest — and GPTBot, ClaudeBot and the AI crawlers apps add to it) always gets its own page, and its page is never kept for a browser. Turn it on only when a page is the same for everyone without a cookie: a page that changes by the browser's language or device without saying so in its headers is not for it. "pageCache": true under node in sixpanel.json does the same.

Optimised images survive a deploy. The images Next.js makes for /_next/image are kept in the website's own folder, not in the release, so a deploy does not make every visitor wait for each image to be made again (measured: 1.4 s for an image's first view, then 21 ms). An image nobody has asked for in 30 days is removed by the nightly tidy. Next.js's own data cache still starts with each release, and backups leave these images out — they are made again when asked for.

On a 1–2 GB server, let your CI do the type check. In a TypeScript Next.js build, the type check is the step that needs the most memory, and on a small server it is most of the build's time. The same site held to a 2 GB server's free memory took 75 minutes, 64 of them type-checking, and 16 minutes without that step. If your repository already type-checks every change (a GitHub Actions job running tsc --noEmit, say), skip it on the server only. Add a variable to your sixpanel.json, "env": { "defaults": { "BUILD_TYPECHECK": "ci" } }, and read it in next.config: typescript: { ignoreBuildErrors: process.env.BUILD_TYPECHECK === 'ci' }. The pages the server builds are the same either way. Your CI and your own computer still check the types.

A server app deploys with no downtime: the new version starts beside the old one, must answer on the Health check path, and only then does nginx switch visitors over. A version that fails to start never goes live — the old one keeps serving.

The old version is then stopped the way a server expects: your app receives SIGTERM — also when npm, pnpm or yarn started it — and has 15 seconds to finish what it is doing before it is ended. Stop and Restart stop it the same way, and a stop is never reported as a failure, whatever exit code your app answers it with.

Restart restarts the app where it runs, so the website is closed to new visitors from the moment the old process stops taking connections until the new one answers; they get the "temporarily unavailable" page (HTTP 503) and the page itself on the next try. An app that answers SIGTERM by closing its server and waiting — Next.js does, with next start and with a standalone build, and so does an Express or plain Node.js server that calls server.close() — used to stay up for the whole 15 seconds when visitors kept arriving: nginx keeps its connections to the app open and handed the next request to one the app was still answering, so the app never ran out of work, and every new visitor got the unavailable page meanwhile. SixPanel now lets those connections go once the app has closed its server: the request being answered gets its answer, and the app is gone at once. On our test server, with visitors arriving the whole time, 50 of 80 restarts of such apps (a Next.js app on both start lines, and a plain Node.js server) used to keep the website closed for the full 15 seconds; now none of 119 took longer than 0.4 seconds to stop, and the website was closed for 1.2 seconds at most — the time the new process takes to start. Nothing changes while the app runs, and your own NODE_OPTIONS still applies. An app that was already running when the server was updated gets this from its next start, so its first stop after the update may still take up to 15 seconds. A deploy was never affected: visitors are on the new version before the old one is asked to stop, and in 80 deploys under the same traffic not one visitor got an error.

NEXT_PUBLIC_… and VITE_… values are written into the browser code at build time, so changing one needs Build again; other variables need only a restart (Overview → Restart the app).

When the app has a database, it receives DATABASE_URL and DB_HOST, DB_PORT, DB_DATABASE, DB_USERNAME, DB_PASSWORD and DB_SOCKET in its environment. There is nothing to copy.

PORT and HOST are the panel's: every version runs on its own port and nginx sends visitors to it. A PORT in your .env is not imported, and Environment lists both as set by the panel.

Deploy commands (Settings → Commands before each release goes live) run in the new version's folder as the website's own account, with the variables the app runs with — after the build, and before visitors get it. That is where a database migration belongs: npx prisma migrate deploy, npm run migrate, one per line (a line starting with # is a note). A command that fails stops the release from going live: visitors keep the version they had, and the job's log shows what the command printed.

Files your app writes itself: Kept between deploys (Settings, or keep in sixpanel.json). Every version is a new folder, so a file the app writes into its own folder — an upload, a SQLite file — would be gone at the next deploy. List what must stay, one path per line, like storage/ (a folder ends in /). Those paths live in the website's own data/ folder, and each version links to them: the first deploy that names a path starts it from that version's own copy, and after that what the app wrote is what every new version — and a rollback — sees. Point the app at the kept folder by its full address, /var/www/_sites/<short id>/current/storage (current is always the live version), for example in a variable such as STORAGE_DIR on Environment. A relative path is not enough for a Next.js standalone server, which changes into its own folder when it starts; and a folder the app picks elsewhere, or under ~ (the app's home is the website's tmp/ folder), is not covered. data/ is in the website's backups and goes back with a restore, and Move it to another server carries it and compares it with the original. Do not list what a build makes again (node_modules/, .next/, dist/): the link would put the old build in place of the new one. A website served as static files runs nothing that could write one, so it keeps nothing.

PHP website

  1. Deploys — folder, ZIP or git.
  2. The document root is found from the framework (public/, web/, webroot/ or the top folder). Composer runs when there is a composer.json. A Laravel app made for shared hosting — its top folder has its own index.php and its pages load /public/assets/…, as many CodeCanyon scripts do — is served from the top folder, and the panel refuses the app's own folders (app/, config/, storage/, vendor/ …) while still serving /storage/app/public/ uploads. On every Laravel site, PHP never runs from an uploads/ folder.
  3. Domain & SSL — add the address.

An app that relies on its own .htaccess rules (nginx does not read them) can be served through Apache behind nginx: PHP → Read .htaccess files (Apache) — see PHP and Node.js versions, "Apache and .htaccess".

A PHP website is updated in place: files a new version no longer ships are removed, and folders the app writes itself — list them under Kept between deploys on Settings (uploads, storage) — are never touched. A file from your repository that the app has changed on the server since the last deploy (a licence it activated, an options file its admin page saved) is not replaced either: the deploy keeps the server's copy, names it in the log and ends with a warning. It is not removed either when a later version stops shipping it. The PHP packages folder (vendor/, or the vendor-dir your composer.json names) is Composer's, so it is never counted as changed by the app. A vendor-dir that would hold the app's own code (its document root, a folder it autoloads, the top folder, or a path with ..) is not taken for that folder. To ship the repository's version of such a file, put that version back on the server first; to keep it for good, list it under Kept between deploys. Commands after each deploy runs your own lines as the site's account, for example php artisan migrate --force.

Composer never works in the folder your visitors are served from. On a website that is already live, the deploy builds everything the new version needs before it touches your files: the new packages, in the new version's own folder on top of a copy of the packages you have now, and Composer's class list for them. Your visitors keep the old files and the old packages all that time. Then the new files are copied in — every changed file waits in a hidden .~tmp~ folder beside the place it is going, and they all arrive in one burst — and the two vendor/ folders swap places in a single step, the moment the last file has arrived. Before this, the files were copied one by one and Composer installed afterwards, so for the whole install — seconds to minutes — the new code ran on the old packages, and a version that needs a newer package than the one you have answered an error for that long. Now that stretch is the burst: milliseconds, in our tests (7 to 9 ms against 12 to 14 seconds). A request gets the old packages whole or the new ones whole — never half of each, which is what a visitor's Failed opening required …/vendor/… error during a deploy was. If Composer fails while it builds the new packages, nothing of your website has changed yet, and the deploy log shows what Composer said. Composer's own scripts (php artisan package:discover and the like) run after the swap, against the new packages, in Composer's order. When the packages changed, the deploy also reloads the website's PHP gracefully (requests in flight finish) the instant the two folders swap — it does not wait to find out that they have — and keeps the files only the old packages had beside the new ones for a few seconds, for code PHP still holds in memory. The packages that were live stay as .vendor-old until the new version is live; a deploy that fails after the swap puts the old files back in one burst and swaps the old packages back behind the last of them, and one whose Composer run fails never touched them. The hidden folders are refused by the web server and are gone when the deploy ends. The changed files are held twice until the burst, so on a disk without room for that the files are copied one by one, and the log says so. A deploy that changes no package is built the same way — only the install is left out. If your repository needs a token that is not in git (a gitignored auth.json: Laravel Nova, Spark, Flux …), the website's own auth.json is lent to Composer while it builds and removed afterwards; it is never printed or shipped. The first deploy of a website, a vendor/ that is a link or a mount point, one of your Kept between deploys paths in or under vendor/, a composer.json that sets its own vendor-dir or bin-dir, and a disk too full for a second copy of vendor/ are the cases where Composer installs in place as it always did. Where the packages can be swapped but cannot be built before the files are copied — a pre-install-cmd script (it expects the new files in place), a Composer plugin among the packages (symfony/flex, composer/installers …; php-http/discovery, composer/package-versions-deprecated and pestphp/pest-plugin are known to need no such wait), a version without a composer.lock, a composer.json or composer.lock you keep between deploys, a path repository linked by an absolute path, or a path or artifact repository whose folder is only in your website's own folder and not in the repository — Composer runs after the copy and the new files meet the old packages until it is done. And where only the class list cannot be built first (an authoritative class map, or class files of your own in a folder that composer.json lists by name), it is rebuilt right after the copy. The deploy log says which case it was and why. A website without Composer gets the one-burst copy too: its new code is no longer half old, half new while it is copied.

Refused addresses on Settings takes one path per line (for example /install): visitors get "not found" for it and everything under it, before PHP runs. Use it for an app's own web installer once it has done its work — many CodeCanyon scripts leave theirs open, and anyone who reaches it can point the live site at a database of their own. The website's Overview tells you when this is the case: when the app's own route files still declare an installer under /install, /installer or /installation (or the document root still holds install.php or an install/ folder) and the app is already installed — its database has tables, or the app wrote its own "installed" marker — a yellow card says The app's web installer is still open, with one button, Refuse /install, which adds that address here. The panel never refuses it by itself (you may still be installing), and never opens the address to check — on some apps opening an installer step runs it.

Files the server never serves. Whatever kind of website it is, a visitor gets "not found" for a dotfile (.env, .git), for a database or backup left in the web folder — .sql, .sqlite, .sqlite3, .db, .dump, .bak, .old, .save, .swp, .log, .ini — also when it is compressed (backup.sql.gz, dump.sql.zip), and for a key (.key, .pem). A plain .zip or .gz download is still served. A WordPress website also refuses the folders its backup plugins write to (UpdraftPlus, WPvivid, BackupBuddy, BackWPup): those plugins protect them with an .htaccess file, which nginx does not read. All-in-One WP Migration and Duplicator give you a direct link to their archive, so their folders stay reachable: download a backup from the plugin's page, then delete it from the site.

The visitor's address your PHP code sees (REMOTE_ADDR, and the X-Forwarded-For and X-Real-IP headers) is set by the server, never taken from what a visitor sends — so a sign-in limit in your app cannot be dodged by sending a made-up address. Behind Cloudflare it is the real visitor. If you put a different proxy or CDN in front of a PHP site, your app sees that proxy's address for every visitor: the server takes a visitor's address from Cloudflare only. The same goes for the site's own address: X-Forwarded-Host, X-Forwarded-Proto and X-Forwarded-Port are the name, https and port the request arrived on, so the links your app builds always point at your site.

For a database, the Database page shows the name, user and password, and Write these into the app's .env puts them into the .env in the site folder in one press — DB_HOST, DB_PORT, DB_DATABASE, DB_USERNAME, DB_PASSWORD and DB_SOCKET (plus DB_CONNECTION=mysql when the file had none, or had Laravel's sqlite default). Every other line of the file stays as it was. Host localhost uses the local socket — the fastest way in. Change password updates that .env too, as long as it names this site's database.

The PHP page sets this site's limits (memory, upload size, execution time, input variables, time zone, display errors, disabled functions, extra php.ini lines) and its worker pool. Each field shows its default, and a field left empty goes back to it. A value PHP or the web server will not accept is answered with what they said and is not saved: the page keeps showing what the website is actually running on. Its PHP version card moves the website to another installed PHP version and turns on extensions for this website only — see PHP and Node.js versions. Extensions are otherwise per PHP version: the list shows what is installed for the website's version, and searching finds one to add — installing it makes it available to every website on that version. The ones SixPanel needs cannot be removed.

PHP sessions end. A PHP website's own sessions (session_start()) are kept in the site's private folder, and PHP removes the ones nobody has used for longer than session.gc_maxlifetime — 24 minutes unless your app sets its own. A visitor who was away longer signs in again, and a session younger than that is never removed by the server: not by a restart, an update, a deploy, a rollback or the weekly clean-up of PHP's temporary files. To keep sessions longer, set Session lifetime on the PHP page (under Options → Advanced, up to a year) or add a line such as session.gc_maxlifetime = 86400 (one day, in seconds) under the extra php.ini lines. If your app sets its own lifetime in code, that one is used. Laravel keeps its own sessions and WordPress itself uses none, so neither changes.

Where the sessions are kept — Files or Redis. A PHP website's PHP page has a Sessions card with the choice. Files is the default and is right for one server. Redis keeps the sessions in the website's own Redis (see Redis under Database below) — what a second server or a load balancer that does not stick a visitor to one server needs. See Sessions: Files or Redis under PHP below.

How much memory the websites may take. A PHP website starts workers only while there are requests for them, up to Most workers at once on its PHP page — by default a figure taken from the server's memory, about 15 on a 4 GB server. A Node.js app may use up to its Memory limit under Settings, by default half the server. Both are limits, not reservations: an idle website holds no worker at all. That limit is not what pushes the database's cache out: with the database's memory kept in RAM (Server → Database), a website that grows takes from itself first — measured on a test server with the memory of an 8 GB one, a website growing to its limit of 3.9 GB during a build left the database at 0 MB in swap, and without that protection at 101 MB. Lowering the limit does not help the database and hurts the website: at 2 GB the same website kept the database whole only by swapping 2 GB of its own memory. So the default stays; lower it for a website you know to be small. Builds take turns: on a server under 8 GB one build runs at a time, and on a larger one a build that needs more than a quarter of the server's memory waits for the other large ones (its log says so), while a small build runs beside them. Health → Service memory budget adds the limits of every website up and says, beside them, what is true at that moment — how many of their PHP workers are running and how much memory those use, and what the Node.js apps use. As a guide, a stock WordPress took about 12 MB a worker on a 4 GB server (all 14 workers together: 171 MB); Server → Health counts 32 MB a worker, so that a website with many plugins is not under-counted. A website that has moved to another server and is parked here, a static website, and an app that is switched off run nothing and are not counted. Limits are what a service MAY take, not what it takes, so these sums are information: the row turns amber only while the server is measurably short of memory now (tasks waiting on memory, available memory under its floor, a process killed for memory or pages read back from swap since the last look), and then it names these limits as the likely cause. The measurement is in the row either way. While memory is short, Memory headroom is the one amber row and names the others as its causes, so one shortage is one item on Home. A shop's storefront or queue worker that is switched off (or a server with no shop at all) has no limit to count, so only the ones that are on or running are added.

…and how many database connections. A PHP worker holds a connection to the database while it serves, and one MariaDB serves everything on this server. So its connection limit has room for every website's workers and every running app, raised by itself as websites are added — The database server says how it is counted, and Health → Database connections shows how close the server has come to the limit.

WordPress

  1. Create it (title, administrator, language) — and give its web address in the same dialog if you have it: WordPress then installs itself on that address as soon as it is connected, in the language you chose, with the database already connected.
  2. No address yet? Add it later on Domain & SSL; the install starts then.
  3. WordPress → Open WordPress signs you in as the administrator with a single-use link — no password needed. Show the password shows it if you want it.
  4. Mail. PHP's mail() is off on a new website, so WordPress sends nothing — password resets, new-user and order emails — until an SMTP plugin (WP Mail SMTP, FluentSMTP…) signs in with a mailbox from Email → Mailboxes. The WordPress page says so while it is off. Turning mail() on is on the PHP page, with its risk: Email → PHP mail() and sendmail.

The Deploys page is where WordPress changes:

  • Updates for core, plugins and themes: the card says what waits (WordPress 6.9, 2 plugins) and Update everything is its main button. A restore point (database and files) is taken before every update and every deploy; the last three are kept under History & rollback, and Restore puts the site back. Putting one back first keeps what is there now as a restore point of its own, the site's scheduled jobs wait while it runs, and a restore that stops part way puts that copy back — never a site that is half of each. When another website, a 6amMart project or a staging site names the same database, Restore is refused before anything changes and says who else uses it. A temporary login's restore points never push out yours. Take a restore point now takes one by hand.
  • Deploy your own theme or plugin — from a ZIP (the same file WordPress takes under Add New → Upload), a folder, or git. See Your own theme or plugin.

The WordPress page:

  • Plugins and themes — activate, deactivate, install from wordpress.org, delete (a plugin is switched off first; its settings stay in the database for a reinstall), update one at a time, automatic updates.
  • Page cache in nginx: visitors who are not signed in get a stored page; anyone signed in, commenting, or with a WooCommerce cart gets a fresh one. A visitor who arrives from an advert or a newsletter gets the stored page too: an address whose only arguments are advertising or analytics tags (fbclid, gclid, utm_…, msclkid, mc_cid and the like) is the same page. Their browser still has the whole address, so your analytics count the visit as before; a plugin that reads those tags on the server rather than in the browser does not see them when the page comes from the store. Any other argument — a search, a preview, an add-to-cart link — is built by WordPress every time. It is cleared the moment you publish or edit, and whenever SixPanel changes how the site is served (a SixPanel update, a setting you change). A page your site itself marks as private or not to be stored — which PHP does for any page that starts a session — is never kept, so one visitor is never shown another's page; such a page is built by WordPress on every visit. Nothing built for an address with arguments is kept either, and no redirect is. A stored page is used for 30 minutes (or for as long as your site itself says it may be kept); after that the next visitor gets one WordPress builds afresh, so a page you have since made private stops being shown even if nothing cleared it. The stored copy is only shown past that time while PHP is failing.
  • Security — on by default: the file editor inside WP Admin is off, xmlrpc.php is blocked, PHP never runs from the uploads folder, sign-in is limited to one attempt a second per address, visitors cannot list who writes there (?author= and the REST API's user list, however the address is spelled — and the administrator's public name is the site's, never the login), and the WordPress version is hidden. The file editor, xmlrpc.php, the sign-in limit and the user listing are switches; the uploads rule and the hidden version always hold.
  • Tools — debug log, maintenance mode, search and replace across the database (Count matches shows what would change before anything does), and a new administrator password.

Scheduled posts publish on time even when every page is cached: WP-Cron runs from a server timer every five minutes (the first row on Cron jobs), not from visitors. The row appears once WordPress is installed — that is, once the website has its address.

Your own theme or plugin

Deploys → Deploy your own theme or plugin puts the code you write yourself on the site — a ZIP, a folder, or its git repository (Connect git, then one button or every push deploys it). Every deploy:

  1. reads what the files are, the way WordPress does: a style.css with a Theme Name: line is a theme, a PHP file with a Plugin Name: line is a plugin. A repository that holds wp-content/ (or themes/ and plugins/) deploys each theme and plugin in it — never uploads/ or mu-plugins/. A full marketplace download (documentation, licence and the ZIP inside) is recognised, and the installable ZIP in it named; nothing is changed until a theme or plugin is found;
  2. takes a restore point;
  3. replaces that theme's or plugin's folder in wp-content as a whole, the way WordPress's own updater does. WordPress itself, the uploads and every other plugin stay as they are;
  4. turns it on, unless you untick it: a plugin is activated, a theme becomes the site's theme (when the deploy brings exactly one);
  5. loads WordPress with it and opens the site's address. If WordPress no longer loads, or the site answers with a server error it did not give before, the code that was there before is put back by itself and the deploy says why.

The folder is the one you name in the Connect git window, else the folder of the theme or plugin already installed under the same name (so its settings stay its own), else the ZIP's own folder, its Text Domain, or the repository's name. The repository's files are used as they are — commit what a build produces.

Create with AI

Build with AI is a chat with Tia that builds the website the way a programmer works on a laptop: she reads and edits the project's files one at a time, and every file she saves shows up in the preview beside the chat within a second — nothing is built for a change. When you like what you see, Publish runs the production build and puts that version live on your domain. Every change is kept in git, so Undo can take any of them back, and with a repository connected Tia pushes every change there.

Where this server has the coding program of AI Coding installed, Tia writes the website with it — see The coding engine below. Everything on this page works the same either way.

Asking Tia needs SixPanel Pro (Your AllsWeb account and SixPanel Pro): sending a message, attaching files, and Ask Tia to fix it. Without it, Create with AI is marked Pro in the create wizard, and the builder shows the upgrade card in the chat — Build it, Attach and Ask Tia to fix it open it too. Everything that asks no model keeps working: the website stays live, and you can read the conversation and History, Stop a change, Undo, Put it back and Restore this version, Publish, use the preview (Start, Restart, New preview link, Give the address back), and connect git or Push now.

  1. Projects → Create a new project → Create with AI: name it and, if you like, describe the website. The panel sets up a Next.js project and installs it straight away, so it is ready the moment it exists.
  2. AI (in the main menu) — add the provider whose model Tia works with (below). One list serves every project.
  3. Domain & SSL — add the address the website is published at. With the instant preview (below) you can build first and add the domain when you are ready to publish; without it, every change is published there, so the domain comes first.
  4. Open the project's Build with AI page. A description saved at create starts as soon as a provider and the domain are both in place; otherwise say what you want.

The instant preview

  • The instant preview needs this panel connected to an AllsWeb account (Settings → AllsWeb account) whose plan includes test addresses. The first time you open Build with AI, the panel asks AllsWeb for a private test address under sixpanel.dev, gets its HTTPS certificate and starts the website's development server behind it — about a minute, once. The address is removed with the project.
  • Give the address back removes it sooner: the preview stops and AllsWeb takes the address back at once — when AllsWeb cannot be reached, the panel keeps trying until it can. The next time you open Build with AI the panel asks for a new address (or press Set it up now); until then each change is published to your domain.
  • The address belongs to this server. A copy of the project's records on another server never uses it — that server asks AllsWeb for its own.
  • Only a browser that opened the preview through its link sees it; everyone else gets 403, and search engines are told not to index it. Open in a new tab takes you there; New preview link replaces the link, and anyone you gave the old one to loses access at once.
  • The chip beside the preview says what the development server is doing: Live, Starting…, Installing packages… (after a change to package.json), Asleep or Error, with the error's text and Restart. It falls asleep after 30 minutes without changes and wakes when you open Build with AI or send a message.
  • Desktop, Tablet and Mobile show the page at those widths; Reload loads it again (the preview usually updates without one).
  • Without an AllsWeb account, or on a plan without test addresses, Build with AI works as before: the panel publishes each change to your domain when Tia finishes it, and the pane shows your live site. That is slower — every change waits for the production build — and the page says what would turn the preview on.

The coding engine

AI Coding runs a coding program on this server — Claude Code, or Codex with a ChatGPT plan. Once it is installed (on the AI Coding page in the panel's menu), Build with AI hands "write the code" to the same program: it works as the website's own account, in the website's source, and Tia's built-in tools are what she uses where it cannot run. The chat, the preview, the check after a change, Publish, History and Undo are the same for both.

  • Each change says who writes it, in its first line: Tia is writing this change with Claude Code…, or …with her built-in tools and why the coding engine is not used — it is not installed, the server is too small for it (What the server needs), the provider is not ready for coding (a plan that is not signed in), this is a staging site that has not been started, the change was started for you by Tia from the chat, by an automation or by a connected agent (such a change counts against her daily budget, request by request — see What it costs), or the server is already running as many turns of the engine as it can (AI Coding's sessions count too). With a provider that has an API key, a change is never refused for that last reason: Tia writes it with her built-in tools instead. (With a plan as your only provider nobody else can write it — see A plan can build the website below.) The chip at the top right names who would write the next change you ask for on this page.
  • Its rows are its own tools: Read, Write, Edit, Run (a command), Find files, Search. What changed is taken from the files themselves, so a file a command wrote is in the change like any other.
  • It works without asking. Nobody answers questions in the middle of a change, so the engine may edit files and run commands in the website's source by itself — and is refused what Build with AI keeps for itself: git (the panel records every change, and Undo depends on it), a server of its own (the preview's is running), a production build in the source, and the panel's own commands and tools. Publish stays your press: a change is started without the panel's tools, and the panel does not answer its sixpanel command — with either engine. (Codex cannot be refused commands the way Claude Code can: with a ChatGPT plan the lines about git, a server and a build are rules it is told, not locks.)
  • Your provider's key never reaches it. The engine talks to a door inside the panel, which adds the key; a plan signs in as itself. See Providers and plans.
  • A plan can build the website. A Claude or ChatGPT plan answers nobody but its own coding program, so it builds with Create with AI only through the engine. With a plan as your only provider and the engine not able to run, a change stops at once and says what is missing.
  • Its memory. The engine remembers the conversation from one change to the next. After an Undo, a Restore this version, a backup put back, or a change written with the built-in tools, what it remembers no longer matches the files: it starts a new conversation — the change says so — and is given the project's notes (.sixpanel/AI.md) and the chat so far.
  • Attachments reach it as files, in the website's own tmp/ai-attachments folder — outside the source, so nothing attached is published unless Tia copies it into the site.
  • Speed sets how hard the engine thinks; how much one answer may write is the engine's own.
  • A website can be kept on the built-in tools whatever the server has: its builder's engine setting is auto (the default) or builtin. There is no button for it yet — ask Tia in the panel to set it.

Working in the chat

  • The chat says what is still missing — an AI provider, or a domain when there is no preview — with the button that fixes it.
  • Tia's words appear as she writes them. Every file she lists, reads, writes or edits — and every command she runs — is a row; a row with + and − counts opens to show exactly what changed.
  • After a change she opens the pages she changed on the development server. If one shows an error, she gets two more tries to fix it; if it still fails, the error is shown under the change.
  • Stop ends a change while it is being made: nothing more is sent to Tia, and what she changed so far is kept as one change you can undo.
  • Attach images, PDFs or text files, paste a screenshot, or drop files on the box. Send your logo and photos and say where they go ("use this as the logo"); send a screenshot of a design you like as a reference for colours and layout. Images are shrunk in your browser before they are sent, and one message's attachments may add up to 20 MB. Attached files stay private on this server — only what Tia puts into the site is published.
  • After each change Tia offers up to three ideas for the next one. Press one to put it in the box, change it if you like, and send. Ctrl + Enter (⌘ + Enter on a Mac) sends.
  • Speed sets how hard Tia thinks, for this website: Fast answers quickest, Balanced is the default, Best thinks before each answer and uses the most tokens. With her built-in tools one answer may write up to 16,000 tokens (32,000 on Best) unless the provider has its own Max output tokens.
  • The conversation is kept: Tia remembers the whole chat, and when it grows long its oldest part is kept as a summary. She keeps notes about the project in .sixpanel/AI.md, which you can read and edit on Files.
  • You can edit the source on Files too. Your edits are saved as a change of their own before Tia's next one, so Undo never takes your work with hers.
  • Claude (and Anthropic-compatible providers) read PDFs; an OpenAI-compatible provider takes images and text files. (The coding engine opens an attachment as a file.)
  • When Tia adds an npm package, the development server installs it before she checks her work, and package-lock.json is updated with it.

Publish

  • Publish (top left) puts the newest version live: the production build (next build), then the new release takes over only once it answers, so your site keeps serving the current version until then. The last three releases stay on the Deploys page for a rollback. Beside the button: when the site was last published, and how many changes have come since.
  • With the instant preview, the panel publishes a change for you only while nothing is live on the domain yet, so it is never left blank; after that only Publish does.
  • A release takes the preview's installed packages when package-lock.json is unchanged since they were installed, instead of installing them again — measured at a quarter of a second against 15 seconds.
  • If a publish fails, the bar says so, with its log. Ask Tia to fix it puts the request in the box; Tia is shown the end of that log, so you need not copy it.

History and Undo

  • Every change is a git commit in the project: Tia's carry her name, edits made outside the chat are marked Owner. History lists them, newest first, with what each one changed and which version is published.
  • Undo this change puts the files back as they were before it — as a new change, and every later change is undone with it. An undo can be taken back too: Put it back restores the files as they were just before the undo.
  • Restore this version, on any older row, puts every file back as it was at that commit — files added since are removed, files changed since go back. It is a new change on top, so nothing in the history is lost and the restore can be undone like any other. Files git does not keep, such as installed packages and the build, are left alone.
  • Changes made before Build with AI kept a history read the same in the chat but can no longer be undone.

The chat recommends it once there is something worth keeping: Connect git, then the repository's https:// address, an access token that may push to it, and the branch (main unless you say otherwise). The panel checks that the token can reach the repository before it saves anything.

  • On GitHub, use a fine-grained token limited to that repository, with Contents: read and write.
  • Tia's history is pushed straight away, and then after every change — never with force. When someone else pushed to the branch meanwhile, the panel fetches it and puts Tia's changes on top, once; when both changed the same lines, nothing is pushed and the git button turns red with the reason.
  • The git button shows the repository, the branch and the last push. Open it to Push now or Disconnect — disconnecting leaves the repository as it is.
  • The token stays on this server, is hidden in job logs, and is only ever sent to that repository.

AI providers

AI → Providers keeps one list of providers for the whole panel, and the one marked Default answers Build with AI. Adding one is three steps — how, which, connect — and all of it is on Providers: what each way works for, how a subscription differs from an API key, the list and its Default. What matters for a website AI builds:

  • An API key or your own endpoint works for everything, Build with AI included. A subscription — a Claude or a ChatGPT plan — serves the coding of Create with AI and AI Coding only, never Tia's chat or monitoring; see A subscription.
  • Choose a model that is good at writing code and at using tools (function calling): Tia works by calling tools that read and write the site's files. Small local models often cannot. A model is chosen for you when you connect; Change on the provider's row picks another.
  • Max output tokens (under More options) is how much one answer may write. Empty means 64,000 for Anthropic's own API (never more than the chosen model allows) and 16,384 for every other provider — in Build with AI, the Speed setting's 16,000 (32,000 on Best). Raise it when a large page stops half-way; lower it if the provider refuses the value.
  • Before any provider exists, the same setup appears inside the site's Build with AI conversation.

Each provider bills you for its own requests. Keys stay on this server, are never shown again, and are hidden in job logs. A saved key is only ever sent to the address it was saved for: change a provider's address and the key must be entered again. Each chat turn keeps the provider it started with, even if you switch while it runs.

Python and Java apps

Deployed like a Node.js app — a folder, a ZIP or git; a Java app also takes a ready .jar — built here, started beside the live version and moved over only once it answers. What is recognised, what the app is given, the Java versions and the paths kept between deploys: Python apps, Java apps and reverse proxies.

Reverse proxy

Your domain, with HTTPS, in front of an app that runs somewhere else — another port of this server or another server. Nothing runs here; its Reverse proxy page holds where visitors go, the Host header, timeouts, websockets, extra headers (secret ones too), a login and a short cache. Everything about it: Reverse proxy.

Pages every project has

Overview

The four questions a 6amMart project's Overview answers, each a tile that opens the page that fixes it: Is it live?, Can visitors reach it? (an address, and HTTPS on it), Is anything failing? (errors in the last 24 hours — nginx's for every kind, PHP's for PHP and WordPress, the app's own for Node.js) and When did it last change?. When that change was a deploy, the answer also says how long the deploy took ("2 h ago · 1m 52s"); after a rollback, a restored backup or a move it says only when. Until the website is live, the banner above them names the one step still missing and has its button. (A website whose setup did not finish shows the red card described under Create one instead.) Below: the address with Open, Open WordPress (signs you in, no password), what the site runs on, and Empty the cache, Restart and the latest jobs. A Node.js, Python or Java app that runs as a server also has Stop the app: it asks first, and visitors then get a "temporarily unavailable" page until you press Start the app, which takes Stop's and Restart's place while it is stopped (and while it is down after a crash). A stopped app stays stopped when the server restarts; a new deploy starts it. When the panel cannot read the website's jobs or its health just now, the tile says not known and the latest-jobs box says it could not be read — it does not say "no errors" or "nothing has run" over a read that failed; reload the page in a moment.

Docker app

A Docker app's own page has five tabs: App (its services with their state, health, CPU and memory, Start, Stop, Restart and Update images, and the rows its app shows — Supabase's Studio address and keys, BillionMail's dashboard), Environment (the .env, secrets as `**`), Compose file, Logs (what its containers print) and Settings** (memory ceiling, largest upload, the service and port its domain goes to). A Docker app has no Deploys, Database, PHP, Cron jobs, Files or Terminal page: its compose file is what runs. Everything about it — and the one-click apps — is in Docker and one-click apps.

Deploys

The top of the page says where the website stands — the same card as a 6amMart project's Deploys page:

  • Nothing live yet — Put your website on this server: drop a ZIP or a whole folder anywhere on the page, or choose Upload a ZIP, Upload a folder or Connect git. The text under it says what this kind of website expects.
  • Live now — the version visitors get (the upload's name, or the commit and its message), since when and who put it live (manual, git push, Tia or rollback), the repository and branch it comes from, and what runs it, with Open site and Update (or Update from a ZIP or a folder for an upload). While something is missing, the missing step — Add a domain, Connect & get HTTPS — is the main button. Automatic deploys sits in the same card.
  • Suspended — in place of Live now while the account the website belongs to is suspended (or being deleted): visitors get the suspended page, and the version the card shows is what they get again once the account is unsuspended (or restored). Automatic deploys reads refused: a push deploys nothing until then. The website's Overview answers Is it live? with Suspended too.
  • A Node.js app read but not built — the checklist (see Node.js app).

A deploy, build or rollback shows as a card at the top of the page that ticks off its steps, and the page updates itself when it ends; Watch the log opens the log. A deploy that fails says so at the top, in a red card: why it failed in one sentence (the variables it needs, the branch, the file the start command runs, or for a build stopped for memory its memory line, peak, the swap it was given and what the next build is planned for), and one filled button that fixes it — Type the missing values, Connect git again, Switch the branch, Open the app's log, Change the start command, Free disk space, Raise the account's memory or Deploy again. Beside it: Try again (the same deploy from git or npm), View log, and for the owner Ask Tia why (Tia reads the job and says why) and Report this. The version that was live stays live. When SixPanel cannot tell why, the card says so and shows the last line: it never guesses. The causes and what to do for each: Troubleshooting.

Cancel a deploy. The running card has Cancel while the deploy fetches the code, reads it, installs the packages or builds — the steps that write nothing outside the new version. Press it, confirm with Cancel the deploy, and the build stops at once: its new version is removed, the version that is live keeps serving and nothing of the new one is left on the disk. The job then reads Cancelled after 41 s by the owner, its card is blue (not red), no failure e-mail is sent, and Deploy again starts it fresh. A deploy of files that Tia, an MCP client or the API sent has the same Cancel. A deploy waiting its turn behind another job runs nothing: it ends right after the job running now. The owner, a temporary login and the website's own account can cancel; the read-only demo cannot. A deploy from files that were sent (Tia's, an MCP client's, the API's) has the same Cancel, and so has a deploy that only reads the files ("build": false through the API) while it fetches and reads them: a cancelled or failed read leaves no new version behind, on the disk or waiting to be built.

Cancel is greyed, with the reason under the steps, while stopping half-way could leave the website in between two versions: during Go live (seconds), while the deploy commands or sixpanel.json's afterBuild run (they may change the database), for a PHP website (its files are written in place), for WordPress updates and theme or plugin deploys, for a restore, and for Build again of the version that is live. A Python or Java build can be cancelled while its code is fetched and read, not once its build has started. From the command line: sixpanel site <short-name> cancel; Tia: "cancel the deploy of shop".

On Projects and Home, a website whose newest deploy failed keeps its Live chip (the old version still serves) with a red line under it, Last deploy failed 2 h ago, that opens its Deploys page; Projects sorts it towards the top, and Home shows its failure card above the projects.

A version that failed does not stay on the disk. A Node.js, static, Python or Java website is built in a folder of its own, with its packages and the build's cache in it — gigabytes for a Next.js app. When a build fails (it ran out of memory, a command stopped it) or is cut short (the server or the panel was restarted under it), that folder is removed as soon as the deploy ends, and at the next start of the panel for one that was cut. The version stays in History & rollback as failed, with no size, and View log still shows why; nothing else is lost, because nothing was ever served from it. A website whose build keeps failing no longer fills the disk one attempt at a time. A Node.js app whose files were read and wait for their address keeps its folder, also when its first build fails — Build again builds from it — and so does the live version and the earlier ones kept for a rollback. A version that was live once keeps its files too when a rebuild of it fails (for example, the server ran out of memory): they are what you recover by hand, and the next deploy that succeeds tidies them with the old versions.

A Next.js redeploy starts from the last build's cache. Each version is built in a folder of its own, so next build used to start with nothing and said No build cache found on every deploy. Now, after the packages are installed and before the build, the deploy puts the live version's .next/cache into the new folder, and the log says so: Next.js build cache carried from release 20261111-184100 (…) — this build starts warm. Next.js decides itself what in it is still good, so a deploy of the same code is much faster and one with changes rebuilds only what changed. Turbopack's cache files are never rewritten once written, so they are shared with the live version (hard links, no second copy on disk); every other file is copied, so the new build never changes the live version's. It is carried only when the new version installs the same Next.js version (an upgrade builds from nothing once), never the images Next.js optimised (they are already kept across versions) and never fetch-cache, the data your pages fetched — a deploy fetches it fresh, as before. A cache over 2,048 MB is not carried: that build writes a new one. The versions kept for a rollback still keep no build cache, so the disk holds what it held before. A build that starts warm may use less memory; it never lowers what the next build is planned for, so a later build that starts from nothing (after a Next.js upgrade) still gets enough.

A standalone Next.js version keeps one copy of its server files. output: 'standalone' makes .next/standalone/.next/server and .next/static as copies of .next/server and .next/static — on allsweb.com's own site that was 1.8 GB of the same files twice, in every version kept. After the build, each file that is byte for byte the same in both places becomes one file with two names (a hard link): every path is still there and reads the same, nothing is deleted, and the disk holds it once. A file that differs is left as two files. The log says how much it saved (standalone server: … identical file(s) … share one copy … MB less on disk). A Next.js app that runs with next start (not standalone) is not touched.

A new upload, and Build again. Every upload (a ZIP, a folder, files Tia sends) and every deploy from git, Deploy again on the Update dialog included, makes a new version in a folder of its own. Its packages are installed there from scratch with the install command, and nothing of the previous version's node_modules is carried over. A dependency your package.json asks for as latest or as a range is the newest one at that deploy, unless your files carry a lockfile that names an exact version. Build again is different: it builds the same version again in its own folder, with the packages already installed there (npm answers "up to date"), so it is quick and gives the same versions, and its log says "live again". To pick up a newer latest, upload the files again or deploy again from git.

A PHP website is the exception, because it is updated in its own folder. When its deploy fails after the new files were copied in (Composer could not install, one of your deploy commands failed), the new files are already what visitors get, and the page says so: The new files are already in the website's folder, but the steps after that did not run. Live now then names that version as in the folder, not finished. When the copy itself was cut short, the page says the folder may hold a mix of old and new files. Either way: fix the cause and deploy again, or put an earlier version back from Backups. A deploy that stops before the copy changes nothing, and the page says that too. The packages are the one part that never goes half-way: Composer builds them beside the live ones, so a Composer run that fails leaves the packages your visitors are served exactly as they were.

Below that:

  • Changes on the server — for a website connected to git, the repository and branch it reads, with Change git connection always in sight, and the files that changed on the server since the live version (see Changes on the server: commit and push).
  • Update from a ZIP or a folder — the same three ways in. With git it shows the saved repository and Update; Change repository or branch opens the Connect git window again.

Update looks before it changes anything. Press Update on a website that comes from a repository and the panel first asks the repository what is new:

  • Up to date — the version that is live is already the newest commit on your branch. Nothing is rebuilt. If you want the same version built afresh and restarted (after changing a variable, say), Deploy again is there as a second, deliberate button.
  • New commits — each one is listed: its short id, what it says, who made it and when. Update now puts the newest one live. The new version is built beside the live one and switched in when it is ready, so visitors keep the current version until then, and a build that fails changes nothing for them.
  • The repository could not be read — you are shown exactly what git said (a wrong branch, a token that expired), and nothing is changed. Look again retries.

When the live version did not come from the branch — you uploaded it, restored a backup, or it is much older — the panel says so and lists the newest commits instead of counting.

  • Automatic deploys — deploy on every push (see Deploy on every git push).
  • History & rollback — every version with its state (live, ready to restore, failed), how long its deploy took ("Ready in 1m 52s", "Failed after 48s", and how long it first waited for another job or build), whether that was faster or slower than the deploy before it (said only when both times are known), and Make live on any of the last three good ones: switching back is instant, and the version is live since that moment. A failed version has only its log left, not its files. A PHP website is updated in place, so its earlier versions show as replaced and Backups puts one back. A version whose files were copied in by a deploy that then failed shows as in the folder, not finished.
  • Background jobs and their logs — this website's deploys, builds, address and database jobs, each with how long it took and View log. Each project keeps its own newest eight, however busy the server is.

Connect git opens a window in three steps — it closes only from its own buttons, never from a click beside it, and Back keeps what you typed:

  1. Repository — the address from GitHub, GitLab or Gitea (https://… or git@…) and how the server reads it: nothing for a public repository, an access token over HTTPS, or a read-only deploy key over SSH. For a deploy key the panel makes one (ed25519 or RSA) or takes one you already have, shows its public half with Copy and a link to the repository's Deploy keys page; leave Allow write access unticked, unless you want to push changes made on the server back to the repository (Changes on the server). The private half never leaves the server. Continue first tests the connection and lists the branches. An address pasted with a name and password inside it (https://name:password@…) is saved without them: the panel keeps them as the access token and shows, logs and records only the address.
  2. Deploy — what will happen, then Connect only or Connect and deploy.
  3. Automatic deploys — turn on deploying on every push, right there (see Deploy on every git push).

A Create-with-AI website gets its versions from Build with AI: the page names each one by the request that made it, and Make a change opens the chat. There is no upload form — Tia's next change would replace an upload. For WordPress the page shows WordPress and its updates, restore points as the rollback, and your own theme or plugin — see WordPress.

Domain & SSL

The page opens with one verdict — Every address is set up and secure, One thing needs your attention (or how many), or Give this website its address — with Open for the main address and Re-check DNS.

Below it, one card per address the website answers on, each with two facts:

  • Reaches this server — through Cloudflare, which is the usual way (every record the panel makes is proxied, the orange cloud), or directly when the domain's DNS is somewhere else. A name in a Cloudflare account added to the panel that skips Cloudflare — a DNS-only record — is marked, and connecting again turns the orange cloud on. When the panel cannot read where a proxied record goes — no Cloudflare token for the domain — the card says so instead of guessing. Goes through Cloudflare to a different server means the record points at another machine; change it, the panel never overwrites it.
  • Secure — the https padlock is on: the free Let's Encrypt certificate, the day it is valid until, and that it renews by itself — the server checks every night. A certificate close to its end, expired, missing a name, or without renewal settings is marked here, and the verdict says what to press.

When a name does not reach this server yet, its card carries the fix: the exact record to create — an A record for the name, pointing at this server's IP address, proxied — with a Copy button for the address; or, when a Cloudflare account added to the panel holds the domain, Create the DNS record, which makes it and gets the certificate in one go — with that account's token, whichever account it is. The www / bare twin that sends its visitors to an address is shown inside that address's card, with its own two facts.

The Cloudflare strip above the cards names, for each Cloudflare site the website uses, the account that holds it and whether its settings are as recommended; Manage → opens that site with the website's own settings in view. A website gets the HTTPS, speed and security settings and its orange-cloud records — never a shop's 6ammart rules, even on a domain it shares with one. See Cloudflare.

Add an address (or Add another address): type the name, like shop.example.com. Under the field the panel says where that name lives, as you type — a Cloudflare account added to the panel holds it (the record and HTTPS are automatic), it is on Cloudflare under another account (paste that account's token, or make the record yourself), it is not on Cloudflare (the A record to make), or it already points here. Then press Add and connect:

  • when the panel can make the record, or the name already reaches this server, it connects at once — the record, one certificate for every address, and serving on it; a WordPress site is installed on it at the end. The steps show on the page while they run; Watch the log opens the full log;
  • when the record is yours to make, the address is added and its card shows the record. No job is started that would only fail: the panel looks for the record once a minute for seven days and connects the address by itself as soon as it answers. Re-check does the same at once.

Tick Also answer on … to add the www / bare twin as well — example.com and www.example.com are one domain, so they share one card. While the twin is coming, the form asks Visitors see: example.com or www.example.com. The one you pick is the address visitors see; the other sends every visitor to the same page on it (a 301, with the path and the ?query kept), and search engines follow it. A subdomain such as shop.example.com is one name and gets no twin. When something is not secure and the panel can fix it, the verdict offers Connect & get HTTPS (or Get HTTPS again once a certificate exists); when the last attempt stopped, the page says at which step and why, with View log.

Visitors see stays on the domain's card: press the other spelling to turn it round at any time. The certificate already covers both names, so nothing else changes — and a WordPress site on that domain moves with it (every address it stored is rewritten). You do not need a Web Rule for www ↔ non-www: the Web Rules page says it is done here.

A second domain (an old one, a typo, another spelling) has its own card with This domain: Shows this website — the same website under its own name — or Send visitors to …, which turns every page of it into a 301 to the same page on the primary address. Its own www twin follows it either way. When the other name of the primary's own pair also shows the website (both example.com and www.example.com serve), Send visitors to … on it is the turn-round: it becomes the primary's 301 in that one press.

Make primary on the other spelling of the primary's pair turns the pair round too: the old primary becomes the 301 to the new one, so the two spellings never both serve. After any of these presses, and after Remove, the panel asks every name on this server, over http and https, and says so when its redirect and the app's own redirect send visitors round in a circle (a redirect loop, so the site would not open) — with what to change. It asks the same when Connect & get HTTPS has finished (the app's own redirect often meets the panel's only once the names serve over https) and each time a new version goes live (its redirects may be new): there the warning is a line in that job's log, and the site still goes live.

Under More on each card: Make primary — the address the app is told about, and the one WordPress lives on — and Remove. Making another address primary, or removing the primary, moves a WordPress site to the new one: every address WordPress stored is rewritten, in a job the page shows. Remove takes the name's www / bare twin with it, and it does not take the name off the certificate: all the website's names share one certificate, and renewal has to prove every one of them, so when a name you removed stops reaching this server (a domain moving away is the usual reason) the whole certificate would stop renewing about 60 days on. The page says so when it happens — press Connect & get HTTPS and the certificate is issued again without that name. How pointing a domain here works at the bottom explains DNS once, with this server's IP address to copy.

On a staging site this page works the same way. A copy made on a temporary sixpanel.dev address shows that name here — its record is AllsWeb's, so the page never offers to change it — and you can add your own domain beside it, connect it and make it the primary. Removing the temporary name then gives it back to AllsWeb. A copy's own domain is an ordinary address of yours (proxied on Cloudflare, counted by the check-up); what makes it a copy's is only that search engines are told not to index it and nothing is served from the server's cache. A copy that is not started answers one sentence on every address it has — the certificate check still gets through, so Connect & get HTTPS works while it waits. See Staging & Testing.

A free test address

A website with no address yet can answer on a free sixpanel.dev test address: tick No domain yet? Use a free test address when you create it, or press Use a free test address on an empty Domain & SSL page. Its card carries a test address badge.

  • The name comes from your AllsWeb plan (the same names staging sites and Build with AI use). AllsWeb makes its DNS record, pointing straight at this server; the panel writes no Cloudflare record for it, and gets its certificate over HTTP. With Allow traffic from Cloudflare only on, the test address still answers — that one name is let through; your own domains stay locked.
  • Use my own domain. While the website has a test address, the add form on this page is called Use my own domain. Type your domain and press Use this domain: the panel adds it (with its www twin) and connects it like any address. The moment your domain has HTTPS, it becomes the website's address, the test address is removed and given back to AllsWeb, and its certificate is deleted. Your domain's certificate never carries the test name. If your domain's DNS record is not there yet, the card shows the record to make and the panel looks for it every minute for seven days; the test address keeps working until your domain is ready. If the connect stops before the swap is done (the server could not load the new configuration, say), nothing is given back: the website keeps answering on its test address with the test address's own certificate (your domain is not shown as having HTTPS yet), the job's log says why, and Connect & get HTTPS finishes the swap.
  • Removing it on its card, or deleting the website, also gives the name back. If AllsWeb cannot be reached at that moment, the panel keeps trying at every start and every hour, so a name never stays pointing at this server. If this server's address changes, the test address follows it.
  • A website on a test address is not moved to another server: give it your own domain first. The test address is not written into its sixpanel.json.

SaaS domains

For a website that is a platform hosting businesses — a booking app, a website builder, anything where each business brings its own domain. Your app adds and removes those domains itself, through the panel, and this page shows them all. It is there for the kinds that run their own process: a Node.js, Python, Java or Create with AI website.

They are not on Domain & SSL on purpose. There, every address of the website shares one certificate, and renewing it has to prove every name on it — so one business whose domain moved away would stop the renewal for every other business, and anyone who opens the certificate would read the list of your customers. Here every business domain has its own certificate and its own web server settings.

The website's menu has SaaS domains only for a website that is such a platform: SaaS domains are on, it still serves business domains, or its sixpanel.json asks for them. Any other website reaches the page only by its address, and the page then says in one paragraph what it is for.

Turn on switches it on. The app gets a private socket to reach the panel through, and its environment gets SIXPANEL_SAAS_SOCKET, the socket's path — so the app is restarted once, the way a change on Environment restarts it. That restart is a job of its own: it waits behind any job already running, and the app has the socket once it has run. The same switch can be written in the website's sixpanel.json ("saas": { "domains": true }, see sixpanel.json). Said yes to in a deploy, it is turned on before the new version starts, so that version starts with the socket and nothing is restarted for it; when the new version does not go live, it is turned off again.

How many domains. A website holds 1,000 business domains unless you set another limit, up to 20,000. The server also has a ceiling for all its websites together, set by its memory: nginx keeps every domain's certificate in memory, and a reload briefly runs two copies. About 400 domains on a 1 GB server, 900 on 2 GB, 3,900 on 8 GB, 15,600 on 32 GB, and 20,000 from about 41 GB. A limit above that ceiling is refused, and so is a new domain once the server is full. Remove domains, or move the website to a larger server.

Two ways a business connects its domain. The card How businesses connect their domains shows both:

  • Cloudflare for SaaS (recommended) — the business points a CNAME at your platform's target, like customers.example.com. Cloudflare issues and renews the certificate visitors see, protects the site, and never shows businesses this server's address — so a move to another server never asks a business to change its DNS. This server keeps a certificate of its own for every business domain too, so your zone stays on SSL/TLS Full (strict). Cloudflare includes 100 custom hostnames on every plan (each name of a domain is one: example.com and www.example.com are two); each one past that costs $0.10 a month, Cloudflare's price. The card shows how many are in use.
  • Point to this server — the business adds an A record to this server's IPv4 address, and this server gets each domain's certificate from Let's Encrypt.

The card says which way new domains take: Cloudflare for SaaS once it is ready, otherwise pointing to this server. A domain your app adds without naming a way takes that one.

Set up Cloudflare for SaaS (the server owner's) asks for one name — the label businesses point at, customers unless you choose another — and does the rest with the Cloudflare token this panel already holds for the website's own domain (Cloudflare page): it makes saas-fallback in that zone pointing at this server, sets it as the zone's fallback origin, and makes customers for businesses to point their CNAME at — every record proxied. A record already at one of those names that is not exactly this is never changed: the card names it, and you remove it in Cloudflare or choose another label. If the token lacks a permission the card names it — Zone → SSL and Certificates: Edit (and Zone → DNS: Edit for the records) — and nothing is written; add it to the token in Cloudflare and press Set up again. If Cloudflare says Cloudflare for SaaS is not enabled on the zone, enable it in the Cloudflare dashboard (SSL/TLS → Custom Hostnames). Cloudflare switches the fallback origin on within a minute; the page follows it.

Moving the website to another server takes its Cloudflare for SaaS setup with it: on the new server, the setup points saas-fallback at the new server, and every business connected through Cloudflare keeps working with no change to its DNS. Deleting the copy the move left on the old server removes nothing at Cloudflare. Set up again on another Cloudflare zone (after the website's own domain moved zones) is refused while its business domains still use the first zone: point them at this server, or remove them, first. The same setup can be written in sixpanel.json: "saas": { "domains": true, "cloudflare": { "target": "customers" } }.

Once it is on, the page has five parts:

  • How your app reaches the panel — the socket's path and the name of the environment variable, each with Copy, and how many domains it may hold (1,000 unless sixpanel.json says otherwise). Only the website's own account can open the socket: there is no password or key to keep, and no other website can reach it.
  • Domains — how many domains are in each state, a search box (a domain, a business's name or id, or a state), Add a domain, and the list: each domain with its names and the one visitors see, the business it belongs to (its name and id, as your app gave them), its state, the day its certificate is valid until, and the day it was added. A domain you added on this page says added here. On a phone each domain is a card. With many domains the list shows the first hundred — search, or press Show more.
  • How businesses connect their domains — the two ways, above.
  • Records to give your businesses — what a business makes where its domain's DNS is managed. Through Cloudflare for SaaS: a CNAME for its domain or subdomain pointing at your target. A bare domain (example.com) can use a CNAME only where its DNS provider flattens it — Cloudflare DNS does; others call it ALIAS or ANAME; otherwise its bare name gets an A record to this server, which only sends visitors on to its www name. Pointing to this server: an A record for @ (the domain itself) pointing at this server's IPv4 address, and a CNAME for www pointing at the business's own domain. A business that uses a subdomain (shop.example.com) makes one A record for that name. A domain on the business's own Cloudflare can stay proxied; its SSL/TLS mode must then be Full or Full (strict). When this server has no IPv6 address, the card says the domain must have no AAAA record: Let's Encrypt tries IPv6 first, and the certificate fails while an AAAA record points somewhere else.
  • Turn off — see below.

When Server → Firewall lets web traffic in from Cloudflare only ("Allow traffic from Cloudflare only"), a card at the top says so: a business domain that points straight at this server cannot reach it, so every one must be proxied through Cloudflare — any Cloudflare account, the business's own included — with its SSL/TLS mode set to Full (strict), and the records card asks for both records proxied. Open Server → Firewall goes to the switch. A domain connected through Cloudflare for SaaS is refused a direct visit to this server's address while that switch is on, like your own names: its visitors come through Cloudflare — except the bare form of a pair whose visitors are sent on to the www form, which keeps its A record straight at this server and its redirect. A domain already connected and pointed straight at this server keeps answering its visitors directly. One that was moved to Cloudflare for SaaS can be put back with Point to this server instead while that switch is on — a choice for you on this page; the website's own app cannot make it through its API. The question says what happens next: a domain that has a certificate on this server answers direct visits again, like every domain pointed at this server; for a domain that has none, the question repeats the card: pointed straight at this server it cannot be reached, so it waits until the business proxies it through Cloudflare or the switch is turned off. (When a firewall in front of this server is what keeps direct traffic out, that button is not offered: a domain pointed straight here could not be reached at all.) The other direction needs care while the switch is on: Move to Cloudflare on a domain that points straight at this server refuses its direct visits from that moment, and the question says so — the domain answers again once the business has replaced its A record with the CNAME its row shows.

What each state means, and what the page shows beside it:

  • waiting for DNS — the domain is recorded, but its DNS does not reach this server yet (or was not read yet). The row lists the records it still needs, with what each name points at now. Through Cloudflare it also waits while Cloudflare checks the name (the row says what Cloudflare says of it), and lists an optional TXT record (_cf-custom-hostname.<domain>) that lets Cloudflare connect the name before its CNAME moves. Visitors who open it already get a short "being connected" page. The panel reads it every minute for the first half hour, then every 5 minutes up to six hours, every 30 minutes up to three days and every 6 hours up to 14 days.
  • getting HTTPS — every name it needs points here and its certificate is being issued, in a job of its own like any other: the bar at the top names it while it runs, and Activity keeps its log. Through Cloudflare it also says this while this server's certificate is in place and Cloudflare is issuing the one visitors see (a few minutes).
  • live — the certificate is issued, and visitors reach the website over HTTPS on the name they see. A domain whose DNS later leaves this server stays live while its certificate lasts, and the row says that its certificate will not be renewed. Such a certificate never fails this server's own certificate checks (Health, the nightly renewal): a business domain's certificate is this page's to report. A live domain whose certificate files went missing gets a new certificate at its next reading. While a live domain moves between the two ways, the panel reads it every few minutes until the move is finished, not once a day.
  • HTTPS failed — the certificate could not be issued; the row says why, and when the panel tries again (after 1 hour, then 3, 6, 12 and every 24 hours).
  • no DNS for 14 days — still not pointing here two weeks after it was added. It is read once a day; your app decides when to remove it.

Check now reads the domain's DNS at once — and asks Cloudflare to check a name that waits there again — and starts its certificate when every name it needs points here. Each row says which way the domain connects. Move to Cloudflare and Point to this server instead move a domain from one way to the other, and ask first. The domain keeps working all the time (while "Allow traffic from Cloudflare only" is on, read the paragraph about that switch above first — the question says what changes): moving to Cloudflare, Cloudflare checks the name while it still points here, and the row says when the business should replace its A record with the CNAME; moving back, the domain keeps working through Cloudflare until the business changes its record, and only then is it removed at Cloudflare. A domain that never got its certificate here was not working yet, and the question says so instead: it gets its certificate once the business points an A record at this server. Nor was one for which Cloudflare is still issuing the certificate visitors see: the question says it works once the business replaces its CNAME with an A record. Remove asks first, then deletes the domain's certificate and its web server settings; the domain no longer reaches the website. If your app still lists the domain, its next sync adds it again — remove it in the app as well.

A name your app only registered is still yours to use. A SaaS domain holds its name against your other websites, your projects and the panel's address only once it has reached this server — its certificate tried or issued. Until then, you can add the name to any website on Domain & SSL (or to a project, or as the panel's address): the SaaS domain is then removed within a minute, before it gets a certificate, and Activity says the name is yours now. Your app's next add of it is refused (reserved). A SaaS domain that is already live is removed here first.

Add a domain is for a business that asks your support instead of using your app. When both ways are ready it asks which one (the recommended one is chosen). Type the domain; for a domain of its own like example.com (or www.example.com) choose what its twin does — sends visitors on to the name they see (a 301), shows the website too, or leave it out — and which name visitors see; the sentence under the choice says the result, like Visitors see www.example.com; example.com sends them there. A subdomain gets no twin. The business's name and id are optional. A domain added here is yours: your app's sync never removes it.

While any domain is waiting for DNS or getting HTTPS, the page reads the list again every 10 seconds by itself.

Turn off asks first. The socket closes, SIXPANEL_SAAS_SOCKET leaves the environment and the app is restarted once. The domains already connected keep working and keep renewing — turning it off never takes a business's site down, and nothing is removed at Cloudflare — and they stay on this page, where you can remove them. Removing a domain also removes it at Cloudflare; if Cloudflare does not answer at that moment, the panel keeps trying until it does.

SaaS domains are the server owner's to switch and edit. A temporary login sees the page and changes nothing; a reseller or a user does not have the page. On a staging site the page says the domains belong to the website it is a copy of. While this server has no email for certificates (Settings), the page says so above the list: Let's Encrypt issues nothing without one.

SaaS domains: for developers

Your app talks to the panel over HTTP/1.1 on the unix socket whose path is in SIXPANEL_SAAS_SOCKET, in JSON. There is no authentication header: the socket can be opened only by the website's own account, and it answers for that website alone. When the variable is not set — on a laptop, or on a server that is not SixPanel — custom domains are not available, and your app should say so instead of failing.

curl --unix-socket "$SIXPANEL_SAAS_SOCKET" http://localhost/v1/info
curl --unix-socket "$SIXPANEL_SAAS_SOCKET" -H 'Content-Type: application/json' \
  -d '{"host":"example.com","ref":"biz_123","label":"Sharma Sweets"}' \
  http://localhost/v1/domains
// Node.js — a server-only helper with a 10 second timeout
const http = require('node:http');
function saas(method, path, body) {
  return new Promise((resolve, reject) => {
    const data = body ? JSON.stringify(body) : null;
    const req = http.request({ socketPath: process.env.SIXPANEL_SAAS_SOCKET, path, method, timeout: 10000,
      headers: data ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } : {} }, (res) => {
      let text = '';
      res.on('data', (c) => { text += c; });
      res.on('end', () => {
        const json = text ? JSON.parse(text) : {};
        if (res.statusCode >= 400) reject(Object.assign(new Error(json.error), { code: json.code, status: res.statusCode }));
        else resolve(json);
      });
    });
    req.on('timeout', () => req.destroy(new Error('SixPanel did not answer in 10 seconds')));
    req.on('error', reject);
    req.end(data);
  });
}

Every path is under /v1. A request body may be 16 KB at most (/v1/sync: 2 MB).

Method and pathBodyAnswer
GET /v1/info—{ site, serverIpv4, serverIpv6, maxDomains, count, acmeReady, acmeProblem, cloudflareOnly, methods, defaultMethod }
GET /v1/domains (?ref=<ref> for one business)—{ domains: [Domain] }
GET /v1/domains/<host>—Domain, or 404 not_found
POST /v1/domains{ host, www?, prefer?, ref?, label?, method? }201 Domain; 200 when it is already there with the same ref; 409 taken for another ref; 409 method_unavailable for a way that is not ready
PATCH /v1/domains/<host>{ www?, prefer?, ref?, label?, method? }Domain — a new ref moves the domain to that business, a new method to that way (it keeps working)
DELETE /v1/domains/<host>—{ ok: true } — also when it was already gone
POST /v1/domains/<host>/check—Domain after a fresh DNS read; starts the certificate when every name points here
POST /v1/sync{ domains: [{ host, www?, prefer?, ref?, label?, method? }], prune? }{ added, updated, removed, unchanged, errors: [{ host, error, code }] }

<host> may be either name of a pair: www.example.com finds the record of example.com.

  • www — redirect (the twin answers 301 to the name visitors see), serve (both names serve) or none (no twin). Without it: redirect for a domain of its own (example.com, example.co.uk) or www. and one; none for any other subdomain.
  • prefer — which name of the pair visitors see, www or bare. Without it: the one that was sent.
  • ref — your id for the business, at most 128 printable characters. label — its name for people, at most 120 characters. Both are shown on the owner's page.
  • method — cloudflare (Cloudflare for SaaS) or ip (pointed at this server). Without it a domain keeps its way, and a new one takes defaultMethod from /v1/info. A way that is not ready answers 409 method_unavailable with its reason.

/v1/info lists the two ways in methods, each { id, ready, recommended, problem } — for cloudflare also target (what businesses point their CNAME at), zone, count and included; for ip also ipv4 and ipv6 — and defaultMethod. Offer a business only a way that is ready; show a way that is not with its problem.

An error is { "error": "<one sentence>", "code": "<code>" } with a 4xx or 5xx status; show its sentence to the business. The codes: invalid_host; reserved — the panel's own name, or a name of any project or website on this server (the website's own names belong on Domain & SSL — and a name the server's owner took from a domain your app had only registered); taken — a SaaS domain of another website, or of another ref here; limit; not_found; off — SaaS domains are turned off; too_large; method_unavailable — the way asked for is not ready here; busy.

A Domain reads:

{
  "host": "example.com",
  "names": ["example.com", "www.example.com"],
  "canonical": "www.example.com",
  "www": "redirect",
  "prefer": "www",
  "ref": "biz_123",
  "label": "Sharma Sweets",
  "source": "app",
  "state": "pending",
  "dns": {
    "checkedAt": "2026-11-02T09:00:00.000Z",
    "ok": false,
    "cloudflare": false,
    "records": [
      { "name": "example.com", "type": "A", "want": "203.0.113.10", "found": ["198.51.100.7"], "ok": false },
      { "name": "www.example.com", "type": "CNAME", "want": "example.com", "found": [], "ok": false, "alt": { "type": "A", "want": "203.0.113.10" } }
    ]
  },
  "ssl": null,
  "error": null,
  "nextCheckAt": "2026-11-02T09:01:00.000Z",
  "addedAt": "2026-11-02T09:00:00.000Z",
  "activeAt": null
}
  • state — pending, issuing, active, error or stale, as described above.
  • dns.records — the records the business must have, each with what is found now: an A to the server's IPv4 address for every name (a www twin may be a CNAME to the bare name instead — alt gives the other way), and an AAAA row when a name has AAAA records that are not this server's (want: null means it must go). Show the ones that are not ok, with copy buttons. cloudflare: true means the name reaches this server through the business's own Cloudflare; its SSL/TLS mode must then be Full or Full (strict). It is never set for a name that goes through your platform's own Cloudflare for SaaS target. The answer to POST /v1/domains, and to a PATCH that changes method or the names, already carries the domain's first reading — the records to show — when the panel reads it within three seconds; otherwise dns is null and the next GET has it.
  • ssl — once issued, { names, notAfter, issuer }. error — why the certificate failed.
  • method — how it connects. cloudflare — through Cloudflare for SaaS: null for a domain pointed at this server, else { id, status, sslStatus, ownership, validation, errors, checkedAt, target, leaving, hostnames } — Cloudflare's custom hostname of the name visitors see and its two statuses (active and active once Cloudflare is done), the optional TXT that proves the name early (ownership, until it is active), one entry per name in hostnames, and leaving while a domain moved to ip still goes through Cloudflare. For a Cloudflare domain, dns.records asks a CNAME to the target for each name: apex: true marks a bare domain (show the flattening note), the bare name of a pair has the A record to this server as alt, via says how the name reaches the server now, and an optional TXT row (optional: true) is the ownership record.

What your app does:

  1. Ownership first. Before a domain is registered with the panel, the business proves it owns it with a TXT record your app checks — _<yourapp>-verify.<host> holding the business's own token. A domain that already points at this server for another business must never be claimable by pointing alone.
  2. Then POST /v1/domains with ref (the business's id), label (its name) and the method the business chose — or none, for the default. Show dns.records that are not ok, the Cloudflare note, the state and the certificate's date; read GET /v1/domains/<host> again while it is pending or issuing, and offer Check now (POST …/check). Let your platform's admin choose which of the ready ways businesses are offered, and the default.
  3. For example.com or www.example.com, offer the twin and which name visitors see — by default the one typed. A subdomain gets no twin.
  4. When a business removes a domain, DELETE it; when a business is deleted, DELETE each of its domains.
  5. Every 10 minutes, POST /v1/sync with every verified domain and prune: true. The list your app sends is the truth: what is missing is added, a changed www, prefer, ref or label is updated, and with prune the domains your app added that are not in the list are removed — never one the owner added on this page. At most 5,000 entries a call. This is also how the domains come back after a move to another server.
  6. Map a request's Host to its business with your own table of verified domains. With www: redirect the twin never reaches your app: the web server answers it.

Database

A website connected to Supabase shows it first, as its own card: Supabase — this server: <app> or Supabase Cloud — <project>, PostgreSQL, its size and how many tables of your own it holds. Manage data opens it in the Database manager (tables, rows, a query, export and import — the same limits as any PostgreSQL database), Open Supabase Studio (this server) or Open the Supabase dashboard (Cloud) opens Supabase's own screens, and Supabase settings goes to the Environment page's card. Its users, its password and deleting it are Supabase's, so this card has none of those. A Supabase on this server is opened with its own .env, read at that moment — only the server's owner opens it, because it holds every website on that Supabase. A Cloud project is opened only when you gave its connection string, and only over an encrypted connection whose certificate is checked; without one the card says what to add.

Name, user, password (Show password, Change password — the panel updates the app's own settings for you; on a PHP website Write these into the app's .env fills them in), size, Export now (a .sql.gz, the last five kept) and Import a .sql or .sql.gz. The database user can reach only this database, and only from this server.

Every import keeps the database as it is first. The panel checks there is room for that copy (the database's size and a quarter), writes it to a folder of its own beside the website's backups, keeps the newest two, and names the file in its answer with the one line that puts it back. With no room, or with free space it cannot read, the import is refused and nothing is changed. A database with no tables has nothing to keep, and the answer says so.

Add to what is there, or replace it. An import runs the file over the database as it is. Tick Replace the whole database with this file to have every table removed first, so the database holds only what the file makes — the right choice for a file with no DROP TABLE lines, which is how phpMyAdmin exports by default: imported over a database that already has those tables, such a file stops at the first one with Table … already exists. Replace asks its own question before anything is uploaded, and the copy is still kept first.

When an import fails. The database stops at the line that failed, and the job says what that left, as a 6amMart project's import does: nothing of the file ran (it stopped at or before its first statement that changes anything), the database is partly imported (a change had run before the error and stayed), or the panel cannot tell how much of the file ran (a file that runs inside a transaction, whose changes are undone when it stops, is one) — and, unless nothing ran, it names the copy it kept. The database server's own words come last in that sentence, and whole in the job's log. Under the import, Copies kept before an import lists those copies (the newest two), each with Put back: one press makes the database exactly as it was in that copy, the tables the failed file made included. What is in the database at that moment is kept first too, so a Put back can itself be undone the same way. If MariaDB refuses to empty the database for a Replace, no line of the file runs, and the job says that instead, with the same copy and Put back.

A database another project or website also uses is never emptied for this one. When another website, a 6amMart project (its record, or its app's .env) or a staging site names the same database, Replace and Put back are refused before anything happens — no copy is taken, nothing is emptied — and the answer names who else uses it. With Replace ticked you are told as soon as you choose the file: before the question, and before the file is uploaded. Give one of them a database of its own first. (An import that adds to what is there empties nothing and is not refused for this.)

On a staging site this page also has Compare with production: it reads the structure of both databases once, changes nothing, and lists what is only here, only on production, or defined differently — tables, columns and indexes (see Staging & Testing). A file imported into a WordPress staging site is followed by one more step, which moves WordPress back to the staging site's own address: the rows of production's export name production's.

Largest tables lists the ten tables that take the most room, each with its size and its number of rows — the first thing to look at when a database has grown.

Slow queries answers "which query is it?" when the site feels slow. Open the section, press Start recording, use the website for a few minutes, then open it again: the statements that took more than a second are listed, repeats grouped, the one that cost the most on top. Click a row for an example of the statement as it ran — only the owner is shown that, because a statement carries its values. Press Stop recording when you have what you need; a recording you forget ends by itself after a day. Recording and Clear the slow-query log are the whole server's: they cover every project on this server, while the list shows this website's database only.

phpMyAdmin is here too — one for the whole server, so it works on a server that has only websites. Open in phpMyAdmin signs you in as this website's own database user, with no password to copy, and turns phpMyAdmin on first if it is off; signed in that way it sees this website's database and nothing else. Turn off when you are done. Only the owner can open it or turn it on.

Redis

A website can have a Redis of its own, added with one button, the way the database is — a PHP website as below; WordPress (its object cache), Node.js, Create with AI, Python and Java the same way (what each uses it for is on the Caching page). Open Database: under the MariaDB card there is a Redis card. Press Add Redis (the memory field starts at 64 MB; it takes 16 to 1024). Only the owner of the server can add, change or remove it.

What the panel makes for the website, and nobody else can reach:

  • A Redis that belongs to this website alone. Its socket sits in a folder that only this website's own account can enter (and the web server's, which still needs the password), so the accounts of other websites on the server cannot open it. The Redis process itself runs as the server's redis account, one process per website; the password is the second lock.
  • A socket, not a port. The card shows its path, /run/redis-site-<name>/redis-server.sock — a file, with no network address. Nothing on the internet, and no other website on the server, can connect to it.
  • A password, made by the panel. The card shows it as dots; Show password reveals it to you (the owner) and writes that down in Activity. The same press shows the lines to paste into the app.
  • It is saved to disk every second and by snapshot, so a restart of Redis, of the server, or an update of SixPanel keeps what is in it. SixPanel puts the Redis of every website back on every update, and starts it again by itself if it ever stops.

Pointing the app at it. An app that has $redis->connect('127.0.0.1', 6379); with no password (the usual line in a redis.php or config/redis.php) is talking to a Redis on the network port. Replace those lines with the ones Show password gives you:

$redis = new Redis();
$redis->connect('/run/redis-site-<name>/redis-server.sock');
$redis->auth('<the password>');

If the app reads a host and a port from its settings, give it the socket path as the host and port 0 (a socket has no port) and the password as its password. In Laravel with the phpredis client that is REDIS_HOST=<socket path>, REDIS_PORT=0 and REDIS_PASSWORD; with Predis, scheme unix and path the socket path. Redis needs PHP's redis extension for the version the website runs on. SixPanel installs it together with every PHP version and keeps it on (it is in the locked, always-on list under PHP → Extensions, so there is nothing to tick). If the Redis card says it is missing, that PHP version was not installed completely: install it again from Software → PHP.

A worked example — an app on PHP 8.1 that connects to 127.0.0.1:6379 and keeps its sessions in Redis for 91 days.

  1. Database → Redis → Add Redis. Give it room for the sessions (see the memory bar below; 256 MB is generous for a taxi app's sign-ins).
  2. PHP → Sessions → Redis → Switch to Redis, and confirm: everyone signed in is signed out once. (Nothing to turn on first: the redis extension is always on.) If the memory limit you gave Redis is under 256 MB, the same job raises it to 256 MB, live; the question before the press says so. From then on the panel writes the session handler and the socket path itself, and the app's own session.save_handler / session.save_path lines or ini_set calls for them are ignored (the panel's setting is locked so a mistake in the app cannot point sessions at the wrong Redis). Do this before you deploy an app that sets those two itself: while Sessions are on Files only the sessions folder is locked, so an app that sets the handler to redis on its own makes PHP open that folder as a Redis address; the pages still open, but PHP only warns and no session is kept, so nobody can stay signed in.
  3. Change the app's Redis lines to the three above (press Show password, then Copy), take out its own session handler and path lines, and deploy. The app now talks to its own Redis, privately, over the socket. Leave a lifetime the app sets itself, such as 7,884,000 seconds: it is the lifetime the sessions get in Redis.
  4. Restarts, updates and deploys now keep every session; Health shows the Redis and the sessions rows.

Sessions have their own database. The panel keeps them in database 15 of the website's Redis, and an app that connects to the socket starts on database 0. The app's own "clear cache" (flushDB(), Laravel's cache:clear on the default connection) therefore leaves the sessions alone. FLUSHALL empties every database, sessions included: an app that runs it signs everyone out, so keep it out of any "clear everything" button.

The app's password uses Redis; it does not run it. With it the app reads and writes its keys, runs Lua scripts, publishes and subscribes, and empties its own databases. Redis refuses it the commands that change how Redis itself runs: its settings (CONFIG, the memory ceiling among them), its users and passwords (ACL), SHUTDOWN, DEBUG, MONITOR, REPLICAOF, and moving keys to another server (MIGRATE, RESTORE). An app that tries gets a NOPERM answer, and nothing changes. The panel does those things with a Redis account of its own, whose password is in Redis's own settings file and is never shown or handed to the website. A Redis made by an earlier SixPanel is changed to this during the update, while it runs: nothing restarts, nobody is signed out, and the app keeps the password it has. Still treat the app's password like the database password, because it reads and changes everything kept in that Redis.

Start Redis. When the instance is stopped the card shows Start Redis (owner only; it is greyed out for anyone else, and for a website that is being moved or is parked after a move, where its Redis is off on purpose and the card says so). It starts Redis with the memory limit the panel holds on record — whatever number the card showed when you opened it — and changes no setting. Redis that already answers is left alone and the job says so. Redis that was switched off by hand on the server (systemctl disable) is switched on again: the panel's own repair never does that, because it cannot know whether you meant it, but you pressed the button. The configuration is written again if it is gone, and the data stays. A website that keeps its sessions in Redis also keeps its password; a website that uses Redis only as a cache keeps it only while the website's PHP still carries it — otherwise a new password is made, the job says so in plain words, and Health warns until you press Show password and put the new one into the app's own settings file. "Redis is running again" is shown only after Redis has answered. Use it when you do not want to wait for the panel's own repair, or when that has used up its tries for the day (see If Redis itself is down, under Sessions: Files or Redis). Save memory on a Redis that was switched off by hand saves the number and says in the job log that Redis is still off; it does not switch it on.

The memory bar shows how much of the memory you gave Redis is used. Change the memory in the card and press Save memory: it takes effect at once, with no restart. When the website only uses Redis as a cache, a full Redis drops the data used longest ago. When sessions are kept in it, a full Redis never drops one — dropping a session would sign someone out — so it refuses new data instead, and that is why the panel watches it.

How much a session takes (measured on a real server, through PHP's own Redis handler, 91-day sessions): about 165 bytes of bookkeeping plus whatever your app stores in the session. A session that stores 1 KB takes about 1.2 to 1.4 KB and one that stores 2 KB about 2.2 to 2.7 KB (Redis's memory allocator rounds sizes up in steps, so a payload of exactly 1,024 bytes costs more than one of 1,000). So 1 MB holds about 6,000 tiny sessions or about 700 to 850 of 1 KB, and a 64 MB instance holds about 45,000 to 54,000 sessions of 1 KB (256 MB about 180,000 to 216,000); a session that carries a whole cart or profile takes more. Every session lives for the whole Session lifetime, a visitor who never signs in included, so a site that is crawled all day fills Redis faster than its signed-in users alone would.

What the panel does as it fills (sessions in Redis): from 80% it doubles the memory limit by itself, live and without a restart, up to 1024 MB and never more than this server can spare (the same free-memory rule as Add Redis); it writes a line in Activity and in Settings → Automatic repairs ("Redis for the website raised from 64 to 128 MB: sessions were using 81 %"), and it never lowers a limit. It waits while the panel is busy with a job (a backup, an update, a password change) and looks again a minute later. If something inside the website lowered the running limit, SixPanel puts your number back first and never works from the lowered one. Health shows the numbers as information from 80% while the panel can raise the limit itself (and for a Redis used only as a cache, which drops its oldest entries as a cache does), warns from 80% when it cannot, and fails from 90% when it cannot raise the limit (already at 1024 MB, no free memory on the server, or that automatic repair switched off) and always from 95%. If Redis fills completely, which only happens when the limit cannot grow: every sign-in then waits for memory, so sign-ins stall for the length of a request (about 75 seconds each), and the pages of the website slow down or time out while those requests hold PHP. This is not only for new sign-ins: a visitor who is already signed in stalls the same way (about 75 seconds), or gets an error page at once, because taking a session, even only to read it, needs a small write. The sessions already stored are safe and everything is back the moment memory is freed (delete keys, or raise the limit in the card — it applies at once). Switching Sessions to Redis also raises a limit under 256 MB to 256 MB (or the most the server can spare) in the same job. Health also fails when Redis cannot write its data to disk (a full disk).

Change password gives Redis a new password without restarting it. Sessions and the data in it are not touched; they stay where they are. When sessions are kept in Redis the panel first gives the website's PHP the new password, then keeps the old one working for as long as a request may run (about 77 seconds, three minutes at most), so a request that began before the change is not refused; only after that does the old one stop working, and the job says so while it waits. The app's own settings file (the auth(...) line) needs the new password: press Show password afterwards. When the sessions are kept in Redis, the panel writes the new password into the website's PHP settings itself.

If Redis's configuration is lost (a restore, an update that stopped half way, a file deleted by hand) the panel makes it again. While the sessions are kept in Redis it takes the password back out of the website's PHP settings, so nothing changes for anybody. When Redis is only a cache (sessions on Files) no such copy exists, so the panel makes a new password, and the app's own settings file (the auth(...) line) still holds the old one: every Redis call from the app is refused until you press Show password and put the new one there. Health warns about it until you have pressed Show password. If the two ever differ, Health fails with "the website's PHP carries an old Redis password" and the panel writes the PHP settings again by itself within a few minutes (Change password does it at once). Nobody is signed out by it: sessions are not stored under the password.

Remove Redis deletes the instance and everything in it. It is refused while the website's sessions are kept in Redis — switch Sessions back to Files first (on the PHP page); everyone signs in once more, and then Redis can go.

What happens to it elsewhere: deleting the website removes its Redis. Moving the website to another server, or making a test copy, arrives with no Redis and with Sessions on Files (the copy says so): press Add Redis there and switch Sessions again if you want it. (A test copy can only be made of a WordPress website, a Laravel app or a static website: a plain PHP app such as the taxi example cannot be copied at all — Staging & Testing answers that it is another PHP app the panel cannot ask — so for it the sentence applies to a move and to a restore, not to a copy.) Its password is a new one, so the app's own Redis lines need it — Show password. Restoring a backup puts the website's Redis back the way its record names it, a new, empty one if it is gone. The data in Redis is never part of a backup and is not copied, and a test copy or a restored copy never shares sessions with the original. A website's own code can read its own Redis password (phpinfo() shows it to that website's code); another website's code cannot.

Where the password can show up in a log. When PHP cannot open a session in Redis (Redis stopped, a wrong password) it writes the session's address — which contains the password — into the website's own php-error.log, in the website's logs folder. SixPanel hides it wherever it shows you text: the PHP errors and App log tabs, the Errors tab, a job's log, and what Tia reads all print `auth=**`. The file itself, and anything that copies it (the Files tab, a download of the logs folder, a backup), holds it as PHP wrote it. That is the website's own password in the website's own file, the same exposure as phpinfo(); after Change password** the old lines hold a password that no longer works. Do not paste a raw log line into a chat or a ticket without looking for auth=.

Environment

For a Node.js app and a Create-with-AI website, the variables are stored on this server, never inside the site's folder, and handed to the app when it starts. Save refuses, with a sentence, a row that has a value but no name and a name written in two rows — nothing is sent until the list is right.

Below the list, the page names the variables the panel gives the app itself and keeps up to date: its database's and Redis's addresses, its port, NODE_OPTIONS (the memory ceiling; flags you add to it go after the panel's) and its address as NEXT_PUBLIC_SITE_URL and SIXPANEL_SITE_URL (the name older apps read). You do not type these. A row you add with one of those names (an address the app should use instead) wins, and the page says so under the list.

A few names are the panel's own during a build: its install and build commands, the deploy commands and sixpanel.json's hooks.afterBuild. The panel starts each of them as the server's administrator account, makes the website's cache folders and hands them to the website before it switches to the website's own account, so in that step these names are the panel's:

  • The folders and settings the panel gives every build: PATH, HOME, USER, LOGNAME, SHELL, LANG, TMPDIR, TMP, TEMP, XDG_RUNTIME_DIR (pnpm 12 keeps its lock folder there; it is the website's own temporary folder), NODE_OPTIONS (the build's memory), CI, the caches npm_config_cache, COREPACK_HOME, YARN_CACHE_FOLDER, PNPM_HOME, COMPOSER_HOME, COMPOSER_CACHE_DIR, WP_CLI_CACHE_DIR and WP_CLI_PACKAGES_DIR, and npm's npm_config_update_notifier, npm_config_fund and npm_config_audit. These count in any spelling: NPM_CONFIG_CACHE is npm_config_cache, as npm reads it. Every other npm setting, like npm_config_legacy_peer_deps or a registry, still reaches the build.
  • The names the system's program loader and the shell read before a program's first line: LD_PRELOAD, LD_LIBRARY_PATH and every other LD_… name, every MALLOC_… and GLIBC_… name (like GLIBC_TUNABLES), GCONV_PATH, GETCONF_DIR, HOSTALIASES, LOCALDOMAIN, LOCPATH, NIS_PATH, NLSPATH, RESOLV_HOST_CONF, RES_OPTIONS, TZDIR, and the shell's BASH_ENV, ENV, SHELLOPTS, BASHOPTS, PS4, IFS, CDPATH and every BASH_FUNC_… name.

The page accepts them and never refuses a save for one. Nothing is taken from the app: the app still gets every variable you saved, with your value, when it starts. The build, the deploy commands and hooks.afterBuild never get these names: they run with the panel's own value where the panel sets one, and without the name otherwise. Once such a row is saved, a line under it says "<NAME> is set by the panel during a build; your value applies to the app only". A Node.js app's and a Create-with-AI website's build log says the same sentence once for each such name; a Python or Java build leaves them out without a line. sixpanel.json's build.env leaves out the same names (sixpanel.json).

For a PHP website — Laravel, Symfony, CodeIgniter or your own code — the page is the app's own .env, the file in the website's folder. It lists each name with the value the app reads, in the file's order:

  • A value is saved exactly as you type it. The panel adds the quotes a space, a #, a $ or a backslash needs, so the app reads back what you typed. A typed ${APP_NAME} is those characters; a line that already takes another variable's value keeps doing so until you change it, and the page says which lines do.
  • Only the lines you change are written again. Every other line stays as it is — its comment, its place, its quoting. A name you take off the list is removed from the file.
  • A value that runs over several lines (a private key) is listed without a field, because a text field would save it as one line. Edit it in Files.
  • The app cannot read its .env stands at the top when a line breaks the rules of the app's loader — most often a value with a space and no quotes, which makes every page of a Laravel app answer with an error. Each line is named with its number and what is wrong, and Write them properly puts them right in one press. (Shown for apps that load the file with vlucas/phpdotenv: Laravel and most others.)
  • A cached configuration. A Laravel app that ran php artisan config:cache reads the cache, not the file. After a save the panel makes the cache again, as the website's own account, so the new values count. An app that is not cached is never cached from here.
  • The file changed since the page read it — a deploy, Database → Write these into the app's .env, or the app itself wrote to it. The save is refused and nothing is lost: reload the page and make the change again.
  • A file that is not UTF-8 text — a password or a name typed in an older editor's encoding. The page shows it and refuses to save, because saving would change those bytes, also in lines you did not touch. Type that value again in an editor that saves UTF-8, or convert the file over SSH (iconv); then make the change here.

Import a .env file writes the lines of a pasted file into the website's .env: a name that is already there gets the new value, and nothing is removed. Download as .env hands you the file as it is. A .env the panel creates is readable by the website's own account only.

Only the owner sees this page, for either kind — it holds the app's passwords. A WordPress site keeps its settings in wp-config.php and its own admin pages.

Build variables of a static website

A static website built from a source project (Vite, React, Astro…) has a Build variables page in its menu. Its build reads each value by name, like import.meta.env.VITE_API_URL in Vite, and writes it into the website's files.

  • They are public. The page says so on top: anyone who opens the website can read them in its files. Never put a secret here. A real secret belongs in a server app (a Node.js, Python or Java app), whose variables never reach a visitor.
  • A name that looks like a secret (…_SECRET, …_KEY, …_TOKEN, …PASSWORD…) gets a warning line while you type it. It is never refused, because some values are meant for browsers, like a publishable payment key.
  • A change reaches visitors after the next build. After Save, press Build again, or deploy. Nothing restarts: a static website runs no process.
  • ${SITE_URL} and ${SITE_HOST} in a value become the website's own address, as they do for an app. The build also gets that address as NEXT_PUBLIC_SITE_URL and SIXPANEL_SITE_URL, unless the project's own .env sets them. Nothing else is added: a static website has no database and no port.
  • A static website with no build command has the page too, with a line saying that nothing reads these until it gets one (Settings → Build command).
  • Import a .env file and Download as .env work as they do for an app. Tia's get_env and set_env read and set them, and say they are public.
  • They travel with the website: Move a website takes them to the other server, and a staging site gets production's, with the address pointed at its own.
  • A sixpanel.json can give them in env.defaults, env.required and env.optional. env.generate is ignored for a static website, because a secret made for it would be public.

Logs

Errors comes first, as on a 6amMart project: each failure of the last 24 hours once, with how many times it happened, when it last did, and whether it came from the web server, PHP or the app. A failure is the server failing a request — an upstream that refuses, a PHP fatal error, a WordPress database error, the app crashing or printing an error, an error in a PHP framework's own log (App log, below: Laravel, Symfony, CakePHP, CodeIgniter and Yii write the reason for a 500 there and nowhere else), and a page that answered a server error (500, 502, 504…) that no log explains — the panel's own availability check counts as a visitor here too. A website with a PostgreSQL database also counts its database errors: the ERROR and FATAL lines PostgreSQL writes for this website's own database users and databases once they have signed in (a query its user may not run, a missing table), shown as Database. PostgreSQL keeps one log for every database on the server; the panel reads it for you and shows each website only its own lines — never another website's, and never PostgreSQL's own (a restart of the database is not your app failing). A failed sign-in is not counted: anyone on the server can try a wrong password with your database user's name, so it says nothing about your app. Nor are a query you typed in the Database manager (you saw it fail there) and the moment an import swaps the new database in. A 5xx answer that one of the logs explains is shown once, as its reason; a 503 is not counted, because maintenance modes answer it on purpose. A framework log has no time zone on its lines, so the panel reads them in the zone your app is set to (Laravel's timezone or APP_TIMEZONE, and the same setting of the other frameworks), or, when the app sets it some other way, in the zone the log's own last write shows. A log file your website's own account may not read (one a root shell created, say) is passed over — your app cannot write to it either. Visitors asking for pages that do not exist, and a rule or rate limit doing its job, are not failures; PHP warnings are listed after them, notices and deprecations not at all. Mark all as seen starts the count again (the Is anything failing? tile on Overview follows it); the log lines themselves stay. If a log could not be read at that moment — the server was too busy to answer in time — the tab and the tile say not known instead of "none", and no alert is sent for that pass; open the tab again a moment later.

The other tabs are the logs themselves: visitor requests and errors (nginx) for every kind; the app's own output for Node.js; PHP errors and slow requests for PHP and WordPress; the WordPress debug log when it is on. A PHP website also has App log: the log its framework writes for itself — where Laravel, Symfony, CodeIgniter, CakePHP and Yii put the exception behind a failed request, which PHP's own error log never holds. The panel shows the newest .log file in storage/logs, var/log, writable/logs, logs or runtime/logs of the app, and names the file; when the app has written none, the tab says so. A website with a PostgreSQL database has Database (PostgreSQL): every line PostgreSQL wrote for this website's own database users and databases (errors, and the statement that caused each), cut from the server's one PostgreSQL log. A log that does not answer within 30 seconds — something other than a plain file at its name, or a disk that is not answering — is not read, and the tab (and a scheduled task's Log) says exactly that rather than showing it as empty. live follows new lines as they arrive. If the connection drops (the panel restarting, a laptop waking) the tab opens the log again by itself and shows it from the newest lines; when it cannot, it says so, and Refresh tries again.

Above every log tab:

  • Filter the lines shown hides, as you type, every line on screen that does not contain your text. Upper and lower case do not matter, and clearing the field brings every line back.
  • Search the whole log (or Enter) looks through all of the log on the server, not just what is on screen, and shows the newest lines that contain your text, with how many there are in all. The text is matched as typed: SQLSTATE[HY000] or $(id) is text to find, never a pattern or a command. It can be up to 200 characters long. A search can read only part of a log, and the answer says so when it happens: one still running after 30 seconds stops there; an output kept in the system journal (a Node.js app's output, and a 6amMart project's queue, scheduler, websocket, storefront and service tabs) is searched through its newest 50,000 lines; a 6amMart project's Laravel log bigger than 256 MB through its newest 256 MB; and the PostgreSQL tab through the newest part of the server's log.
  • How many lines shows the newest 200, 1000 or 5000 lines instead of the live view. Live, as it is written (on a polled log, Newest part, refreshed) brings the live view back.
  • Download saves what is on screen as a text file: the newest lines, or a search's lines. Passwords, keys and tokens in the shapes the panel knows are replaced by ****, the same way a job's log is masked: a value after a name such as password, secret, token or key (DB_PASSWORD=…, "password":"…", PHP's 'password' => '…' and [password] => …, an object's [password:protected] => … too, to the end of the line), a password in an address, a Bearer header, a GitHub, GitLab, Slack or Stripe key, an AWS access key id, a JSON Web Token and a private key printed over several lines — also when the lines start inside the key, and a line of 60 or more base64 characters alone, as a key's line is. A secret in any other shape (a value with no name beside it, such as a password passed to a function) stays as it was, so read the file before you send it on.

The demo has none of these, because it shows no log at all. A temporary login and the website's own account (its reseller or user) have all of them for that website.

Deploys lists the last 10 deploys and builds of this website: how each one went, how long it took, and when. Show log opens its whole log in place, and a deploy that is still running has Watch it run.

Web Rules

Your own redirects, rewrites and response headers, written straight into this website's web server — no .htaccess and no Apache needed. Every kind of website has it. This is where you redirect an old page to a new one (301 or 302), send www to the bare domain, rewrite a pretty address internally, or add a security header such as HSTS. Two tabs:

Web Rules: header rules (security and cache headers)

Up to 10. Each one sets a header (adds it, or replaces the one SixPanel or the app sends) or removes one the app sends. Start from offers ready ones: HTTPS in browsers (HSTS, two years), a Content-Security-Policy starter, X-Frame-Options, nosniff, Referrer-Policy, Permissions-Policy, caching images, CSS and JS for a year, never caching pages, CORS, hiding X-Powered-By. A rule can apply to every answer or only to addresses matching a pattern (for example

`\.(cssjspngjpg)$`), and Also on error pages keeps it on 404 and 500 answers.

Example — HSTS for two years: header Strict-Transport-Security, value max-age=63072000; includeSubDomains; preload, action Set.

A header name starts with a letter or digit, and a value cannot hold a $ (or a " or a backslash): the web server reads a $ as the start of a variable and would send something other than what you typed, so the rule is refused at that field with the reason instead of failing when it is applied.

Web Rules: redirect an old page, or rewrite an address

Up to 25. Each one says what happens — a 301 (permanent, best for SEO), 302 (temporary), 307/308 (the same, keeping a form's method), or a Rewrite, which serves another address while the browser keeps showing the one the visitor typed — for which addresses (exactly this path, paths starting with, or a pattern, where $1 in the destination stands for the part in brackets — it is the only $ a destination can hold), and where to. Keep the visitor's query string carries ?source=email… along. One optional condition narrows it: the domain, the visitor's country (Cloudflare's, since every address of this server goes through it), the device (desktop, mobile or tablet), a query argument, or the full address — each with is, is not, matches pattern or does not match pattern. A condition on a query argument compares the argument's name without regard to case (?UTM=1 is ?utm=1) and its value exactly as the visitor's browser sent it, so a space in the value is %20 there; a name may hold -, . or [ ]. Repeated slashes in an address are merged before any rule is checked (//old is /old). A Rewrite stays inside the website's own folder, so its destination cannot hold a .. step (/../file is refused at that field): write the path from the top, starting with /.

Rules are checked top to bottom and the first that matches answers: drag a rule, or use ↑ ↓, to put them in order. A rule's switch turns it off without deleting it. Past eight rules a Find a rule box narrows the list. HTTPS is already forced for every address, so it needs no rule.

What do you want to do? Below the rules, at the bottom of the page, is one card per common job: the same cards whether the list is empty or full, and whichever tab is open (a job's rules land on their own tab). Pick one, fill in what it asks — your own addresses are offered in a list, never typed — and press Show what will happen: it shows a real address of this website, the status and where it ends up, before anything is added. Add to list puts the rules in the list; Add and save saves them too. The cards are:

  • Move a page — an old address to the new one (301, or 302 only for now).
  • Move a whole folder — every page under /blog/ to the same page under /news/.
  • Send a page to another site — optionally every page under it as well.
  • One address: with or without www — when both answer, keep one.
  • Old domain → this one — when this website has a second address.
  • Trailing slash — every page address ends with /, or never does.
  • Visitors from a country — some countries to their own page.
  • Phones to a mobile site — every page to the same page there, or one page.
  • Security headers — one press for the security headers browsers use.
  • Faster repeat visits — browsers keep files and check pages again.
  • Let another site use your API (CORS) and Hide what runs the site (X-Powered-By).

Only the cards that suit the website are shown: a single-page app and WordPress have no trailing-slash card, because their routes are their own. A card that needs something first (the www address, a second domain) says what to add on Domain & SSL. A card adds nothing it would repeat: a rule already on the list, a security header SixPanel already sends (nosniff, X-Frame-Options, Referrer-Policy and HSTS are sent on every website), and static-file caching SixPanel already does. Each one skipped is listed with the reason.

Both names of a www pair. When one name of a pair only sends visitors to the other (Domain & SSL → Visitors see), your rules run on that name too: a rule for /apps answers at example.com/apps as well as at www.example.com/apps, before the pair's own redirect sends the rest of the address on. (On a 6amMart project a release before this one left the bare name out: the save ended with Try every redirect on this server naming it as a miss, although the rule worked on the other name. A server that updates gets it right without anyone saving a rule again.)

Check these rules. Above the list, SixPanel says when the rules work against each other: two rules on the same address (only the first runs), a rule an earlier one always answers first, a redirect that lands on another redirect (Send it straight there fixes it in one press) and redirects that send visitors round in a circle.

Ask Tia instead. "Redirect /old-page to /new-page" or "add the security headers", on this page or anywhere: Tia (and an agent you connect) uses these same cards, the tester and Undo, and asks you before a save, naming every rule it adds and every rule it takes away. A rule she was not asked about stays as it is (Tia).

Examples:

  • /old-page → /new-page, 301 — a page that moved.
  • Paths starting with /old-shop/ → https://shop.example.com/, 301 — a section that moved to another domain.
  • Pattern ^/blog/(.*)$ → /eu/blog/$1, 302, when the visitor's country matches
`^(DEFRITES)$` — European visitors to the European pages.
  • Paths starting with / → https://m.example.com/, 302, when the device is mobile.
  • Pattern ^(/.*)$ → https://example.com$1, 301, when the domain is www.example.com — every www address to the same page without www.

Test this rule (in each dialog) and Test the rules (under the list) try an address — with a country and a device if you like — and say what would happen: the redirect, the address it is served from, and the headers on the answer. The test uses the rules on the screen, unsaved changes included, and the same matching nginx uses.

Nothing is live until Save. nginx tests the new rules first; if it refuses them, the previous rules stay and the reason is shown. After a save, every redirect is tried on this server: SixPanel asks its own web server what each one now answers, and the job names any that does not answer as tested. One that misses is asked again for up to five seconds while nginx takes the new rules, so the check adds only a few seconds even when the website's app is slow to answer. Undo last save puts the rules back as they were before the last save and applies them at once. A rule never takes the address certificates are renewed through (/.well-known/acme-challenge/) or the push-to-deploy receiver, and a page that would redirect to itself ("too many redirects") is refused with the reason. Server and Date are nginx's own headers and cannot be removed here; the server's version is already hidden. Tia can read, test and change the rules too — Ask Tia on the page opens her with an example, such as "redirect /old-page to /new-page".

On a 6amMart project the same page has an Address picker (admin panel or customer website). Its cards are the moves, the www and old-domain ones, the security headers and, on the admin, CORS. 6amMart's own paths — /api, /login, /admin, /broadcasting and the uploads under /storage/app/public/ — cannot be a rule's source, because the apps, the storefront and the staff use them.

Vhost

Every web server file SixPanel renders for the website — its HTTPS and HTTP servers, its Web Rules, its page cache, and Apache's file when Apache serves it — shown read-only, each saying whether it is still exactly what SixPanel last wrote. Under Your own directives you can add nginx directives of your own: to the server block, and to each location the website's server has (every page, PHP files, the app's answers). It is empty until you write something, and then nothing in the website's server changes. Check with nginx tests a copy of nginx's whole configuration and saves nothing; Save and reload tests the copy, writes the files, reloads nginx and asks the website's address again — your previous directives come back if nginx refuses them or the website stops answering. A 6amMart project has the same page, one host at a time, with the server block only. Only the owner sees this page. Everything it takes and refuses: Vhost and Apache.

PHP

PHP websites and WordPress. See PHP website.

When PHP reloads

One PHP serves every website and shop on a PHP version, and PHP has no way to reload one website alone: a reload restarts the whole of it gracefully (requests in flight finish), and every website on that version starts again with an empty code cache, so its next requests are a little slower while PHP compiles its code again. So the panel reloads PHP only when it must:

  • a website whose PHP settings did not really change is not reloaded at all;
  • changes that arrive together (several websites made at the same moment) share one reload;
  • a job that changes many websites at once — the panel's start after an update, Apply limits now on an account, a new website taking its share of an account's PHP workers — reloads PHP once, when it has written them all, not once per website. Each website's settings are still checked by PHP before they are kept, and one PHP refuses is put back as it was;
  • if that one reload fails, the job fails and says what PHP answered, and the panel remembers that PHP still owes it: pressing the button again, the next change of a website on that PHP version or the panel's next start reloads it. The same holds when the panel stops in the middle of such a job;
  • websites made or deleted a few seconds apart share one reload too: the first one reloads PHP at once, and the ones made or deleted in the next ten seconds join a single reload at the end of those ten seconds. The job of a new website says when its PHP starts, and it ends only once that PHP answers: its last step waits for the shared reload. A deploy that needs that PHP sooner starts the shared reload at once. A website whose PHP keeps workers running (not ondemand) is still stopped at once when it is deleted;
  • a single new website's PHP answers at once, before its first deploy — also right after a settings save, a deploy or the panel's start reloaded that PHP. Only another website made or deleted on the same PHP version in the ten seconds before makes it join that shared reload, as above;
  • a job that gives a website a new PHP — making it, changing its PHP version, restoring it, a staging copy, moving it to another account, unsuspending it — says its PHP is ready only once that PHP takes a connection, so a visitor right after the job never meets an error page. If it does not answer within ten seconds the step fails and says what PHP wrote about it in its log. The same holds for a new 6amMart project's PHP and for Start on a project's PHP on the Services page;
  • a deploy that changes only your code never reloads PHP: a website's PHP looks at its files again every two seconds. A deploy reloads PHP only when the packages it installed changed.

Sessions: Files or Redis

PHP websites have a Sessions card on this page, under the PHP version and the options. It says where the website keeps who is signed in, and what each choice costs and keeps.

Files (the default)Redis
Wherethe website's private folder on this serverthe website's own Redis (Database → Redis)
Survives a restart, an update, a deployyesyes — Redis saves to disk every second
Works with a second server or a load balancerno — each server has its own folderyes
When it is fullthe diskRedis refuses new data and reports an error; it never drops a session

Switching signs everyone out exactly once, and the panel says so before you press: the question repeats it, with the number of sessions that are live when the panel knows it. Nothing else the panel does signs anyone out — not a restart of Redis or PHP, an update of SixPanel, a reboot, a deploy, a rollback, a backup or restore, a self-repair, a password change or a change of PHP version (on Files or on Redis — see below). A session lasts the Session lifetime (91 days if your app asks for 7,884,000 seconds) whichever you choose.

The Redis choice is switched off, with the reason and a way to put it right, when Redis is not added to the website (the card links to Database), when it is not running, or when the PHP version has no redis extension (it is always installed with the version, so this only means that version needs installing again from Software → PHP). Pressing Switch to Redis changes the PHP setting, checks that a session really round-trips through the website's socket as the website's account, reloads PHP gracefully, and puts everything back by itself if any step fails — the website is never left pointing at a Redis that is not there. Switch to files always works. Measured on a real server: the switch to Redis takes under a second, the switch back about half a second, and restarting a Redis that holds 100,000 sessions takes about a second, with every session and its remaining lifetime back afterwards.

Several requests of one visitor at the same time (a mobile app does this) wait for each other the way they do with files, so one cannot overwrite another's session. A request that dies releases its session when the run-time limit has passed — 75 seconds with the default limit, and up to an hour if you set the run-time limit to 0 (files release a dead request's session at once; Redis waits for the lock to run out). The count in the question before a switch is the sessions held now: the session files on disk (some may already be past their lifetime), or the keys in the sessions' own database.

If Redis is killed while a request is running (a crash, kill -9), that one visitor may wait up to 75 seconds: the lock of the session the request was holding is saved with its remaining time and comes back with the data when Redis starts again (the lock ends by itself after the run-time limit, 75 seconds with the default limit). Nobody is signed out and no session is lost; a visitor with another session is not held up.

An app that registers its own session handler in code (session_set_save_handler(), a database or Memcached session class) is ignored while Sessions are on Redis: the panel's setting locks the handler, so PHP goes on using Redis, and the sessions that app kept in its own store stop being read — everyone is signed out once, as for any switch. On Files nothing is locked but the folder, so such an app works as it always did.

Switching clears the old home. Once the new home is proved to work, the panel removes what the old one still held: the session files when you go to Redis, the sessions' own database in Redis (and nothing else in it) when you go back to files. Everyone is signed out by a switch anyway, and a leftover copy could otherwise sign someone back in later — a visitor who had signed out in between would find themselves signed in again with their old state. If clearing fails, the job log says so and the old entries simply expire by themselves; the switch stands.

A reboot. For the first seconds after the server starts, PHP can be ready a moment before a website's Redis is: a request that needs a session in that window fails or sees no session. Nothing stored is lost, and it clears by itself.

While sessions are kept in Redis, the panel refuses to remove Redis or to turn the extension off — each answer names the Sessions card. Changing the PHP version keeps them in Redis, with nobody signed out: the new version's pool is written with the same Redis, and before visitors are sent to it the panel checks that it loads the redis extension and that a session goes through it into the website's Redis and back. If that check fails the website stays on its old version. A version without the redis extension is refused, with the way on: install that version again from Software → PHP (the extension comes with it). If Redis itself is down, the pages of the website still open, but PHP only warns that it cannot reach Redis and no session is kept, so nobody can stay signed in until it is back; Health says so and the panel starts it again by itself, usually within a few minutes — 3 to 10 minutes (it waits while the panel is running another job); a Redis that crashes outright is restarted by the system within seconds. The panel's own tries have a limit, and it is written here so it is no surprise: while the sessions are kept in Redis it tries up to 12 times a day, two minutes apart (a Redis that keeps stopping does not use them up in an ordinary day); a Redis that is only a cache gets 3 tries a day, 30 minutes apart. When the tries are used up the panel stops, and Health says so — it does not go on forever against a Redis that cannot stay up. The way out is the Start Redis button on the Database → Redis card (owner only): it starts the instance at once, writing its configuration again if that is gone, and does not depend on those tries. A website deleted and made again under the same name starts with all of its tries. It does not fall back to files on its own, because that would sign everyone out — Switch to files is a button you press knowing the cost.

Caching

Caching (every kind but a Docker app) opens with Recommended for this website: for Varnish, Memcached, Redis and compression — and the page cache of WordPress, the browser cache of a static website — what each is for, whether it is on here and whether it works (measured on this server when the page opens), and a verdict worked out from the kind of website and from what its own files use, with why, the memory it costs, and Apply or the exact steps. Below it, the page puts Varnish in front of the website, gives it a Memcached of its own, keeps WordPress's object cache in its Redis, shows the WordPress page cache (never on together with Varnish) and whether the server compresses with Brotli — and has Purge cache, which empties all of them and Cloudflare's copy at once. Each is optional and the owner's to turn on; the whole story, with what is and is not kept, is on the Caching page.

Cron jobs

Commands on a schedule, run as the site's account in the site folder: every 5 or 15 minutes, every hour, every day, every week, or your own cron expression (Custom), read exactly as cron reads it. Each task has its own Log and a Run now button. For Laravel, add php artisan schedule:run with the custom schedule * * * * *. A task runs in the same sandbox as a Node.js app: it can write the site's own folder and nothing of another website, 6amMart or the panel. A Node.js website's task runs on the app's own Node.js (and its npm and pnpm): once a release built on another version goes live, its tasks move to that version with it. Deleting a task also ends a run of it that is under way.

Keeps running is the schedule for a command that is meant never to end: a queue worker, or a dispatcher that loops for ever. It is not put on a timer. It starts with the server, starts again 10 seconds after it exits (even one that exits at once, for example while its database is down), and no time limit stops it. Its row shows whether it is running instead of a next run, and Restart restarts it. A deploy, a rollback and a change to the website's environment restart it too, so it runs what is live. A task on a schedule gets one hour per run. A run stopped at that hour says so on its row, which is how a never-ending command on a schedule shows itself. The fix is to choose Keeps running. Server → Health → Website scheduled tasks counts, for the last 24 hours, how often each task failed or was stopped at its time limit, by the task's name. It warns only while a task's last run failed: once a later run ends without a fault, the same counts are shown as information. It counts only runs after the last time you changed the task's command or schedule, and a task you deleted is not counted. When only one website is named, its link opens that website's Cron jobs page. A job from sixpanel.json that asks an address cannot keep running, because a request is over once it is answered.

Files

The same file manager as a 6amMart project's, inside this project's folder (a folder with more than 5,000 entries lists the first 5,000 — folders first, then by name — and says so under the table; the search box finds the rest): click a row to select it — Shift takes every row up to the one you click, Ctrl (⌘ on a Mac) adds one or takes one out — and the bar under the toolbar holds what can be done with the selection: Copy, Move, Compress into a .zip, Extract a .zip or .tar.gz, Rename, change Permissions, Download or Delete (right-click a row for the same menu). Delete moves to the website's own Recycle bin for 30 days — the button beside Refresh opens it to restore an item, delete one permanently or empty it; tick Delete permanently in the question to skip it. A static or Node.js website's files are its live release, so an item restored after a later deploy goes back into the release that is live now. A pick of several items is restored whole or not at all: if one of the names is taken again (or two bin items are the same file), nothing is put back and the answer names it. Permissions on a folder alone keeps it openable — 644 becomes 755, 640 becomes 750, 600 becomes 700 — and a file gets exactly the mode you pick — except .env, .env.* and wp-config.php, which hold the website's passwords and always stay private (600). A Rename onto a name that is already there is refused. Double-click a row, or click its name, to open it; on the keyboard the arrow keys move, Enter opens, Delete deletes, F2 renames, Ctrl+A selects everything and Backspace goes up one folder. Every folder in the path above the list is a link, and the pencil at its end lets you type a path. Upload — or drag files onto the list, each with its own progress bar, and Cancel to stop the one going up and skip the rest (an upload that makes no progress for two minutes stops by itself); New file, New folder; search names below the folder you are in; show or hide dotfiles; a picture opens as a preview, a text file in the editor (Ctrl+S saves, and closing with unsaved changes asks first). It can never leave the folder — a Copy, Move or Compress destination that goes up out of it, or an archive with no name, is refused with the reason, and the dialog stays open. A folder with more than 5,000 names lists the first 5,000 and says so above the list; the search box finds the rest. Everything it does runs as the website's own account. For a static or Node.js site these are the live version's files — the next deploy replaces them, so change your source for anything lasting.

Compress, extract, copy, move, delete and permissions start at once and show how far they are in a strip above the list — the item in hand and how many of how many for a compress, otherwise how long it has been running. The strip is still there after a reload or a visit to another page; at the end you are told and the list is read again. One such action runs in a website at a time, and it cannot be cancelled half-way. The full description is on the panel tour, under Advanced → Files.

Terminal

A shell in the browser as the website's own account, in its folder, with the website's own PHP and Node.js versions first on the path — and the website's SSH access: off until you turn it on, keys only. Both are the owner's; a temporary login cannot use them. The whole of it is on Terminal and SSH.

SSH/FTP

Who may sign in to the website's files. A PHP website or a WordPress site has FTP users — each with its own password, locked into one folder of the website as the website's own account, over FTP with TLS or SFTP — while the FTP server is installed and running on Software; the page shows how to connect. Every website has its SSH users here too while the server takes SSH: its SSH access, keys only. What is off is not shown: with only one part on the page reads FTP or SSH, and with neither the website's menu has no such entry (an old link opens its Overview). The other kinds have no FTP part, and 6amMart projects keep their own SSH/FTP page. The whole of it is on FTP and SFTP.

Backups

Every backup of the server carries every website: its database, and its files — for a static site, a Node.js app or one made with AI the live version (without node_modules, which a restore installs again) and Tia's workspace; for PHP and WordPress the whole site folder, uploads included. Backups are set up once for the whole server on the Backups page, and this page says whether they are on, when the last one ran, and Back up now.

Put this website back lists the backups that hold it — on the storage that holds it, when you have more than one (the page opens on the storage the newest backup went to, or the next one that has this website). Restore asks what to put back — Files and database, Only the database or Only the files — and for the word RESTORE typed. Only this website changes; no other website and no project is touched. Before anything is overwritten the panel keeps what is there now: a WordPress restore point for WordPress, an export of the database for the others. It checks first that the disk has room for that copy — the database's size and a quarter, and for WordPress the code the restore point copies as well (its uploads are not copied); with less, the restore stops before anything changes and says how many MB it needs and how many are free. The files of a static site, a Node.js app or an AI site then install, build and go live like a deploy, and the version that was live stays on Deploys. A website made with AI is not restored while Tia is in the middle of a change — wait for it to finish, or press Stop — and while the backup is being put back Tia takes no new request, Undo or Restore this version on that website; they work again as soon as the restore ends. Only the owner can restore. Over SSH it is the same job: sudo sixpanel backup restore latest --site NAME --what files (or db, or full), where latest is the newest backup that holds that website.

Staging & Testing

This website's staging sites — private copies of it to try a change on, each with its own database, files and address (a temporary one, or your own domain) — one card each, with Create staging site at the top.

A WordPress website, a Laravel app and a static website can have a staging site made on this page. A custom app — another PHP app, a Node.js app, a Create with AI website — cannot: its Staging & Testing page says why, and the ways on. For another PHP app or a Node.js app there are two: AI Coding makes a staging site and sets it up, and you start it; or you add a second website and set a copy up on it by hand. A Create with AI website has the second way only. So does a Laravel app whose database is not on this panel.

Each card says whether the copy is started. Until it is, its address answers only that it has not been started, and nothing of its app runs.

  • WordPress, a Laravel app and a static website are started by the panel itself, once it has asked the app which database it uses and searched the copy's files for production's database password.
  • A staging site of a custom app — one AI Coding set up, or one made on an earlier version — is set up by hand or by AI Coding, and started on its owner's word. A new one is made by AI Coding, not on this page.

On a copy, the page shows that copy and Open production. The whole of it is on Staging & Testing — Started, or not started and A custom app: no staging site.

AI agent

Give this website — and nothing else on the server — to Claude Code, Codex, Cursor or another AI agent. The page has three cards:

  • Connect your AI agent to … — for an agent on your own computer: pick the agent, press Connect, paste what the page shows. The connection reaches this website only.
  • Connections to this project — the ones made for it; Remove stops one at once.
  • Let an agent work on the server itself — for an agent that runs in a shell on the server, as the website's own account.

The page is the owner's. The whole of it is on Connect your own agent and An agent on the server, inside one project.

AI Coding

Write what you want changed in this website in a chat; a coding program — Claude Code, or Codex — does the work on the server as the website's own account, on a staging site first. A static, Node.js, PHP and WordPress website has the page; a Create with AI website has its Build with AI page instead. It needs SixPanel Pro. The whole of it is on AI Coding.

Settings

The page is in plain sections, each with a sentence under every control saying what it changes, and only the website's own kind of settings: Name in the panel, then what its kind has — What visitors are served (static and PHP: the folder, the single-page or index.php switch, the 404 page), How it is built / How it is built and served (static with a build, Node.js, Python, Java), On every deploy (PHP: the commands after a deploy, the files kept between deploys), WordPress security and Speed (WordPress: its four switches and the page cache). A reverse proxy and a Docker app have no build fields: their section sends you to their Reverse proxy or Docker app page. What most websites never change — the static output folder, the health check path, the memory limit, the releases kept, the largest upload, refused addresses, a Python app's workers, a Java app's main class, and every command of a website made with Create with AI — is under one Advanced, open when one of them is set.

One Save for the whole page. Every field, the name too, is saved by the Save bar at the bottom of the form: it wakes when something changed, says You have changes that are not saved yet, and Discard changes puts every field back to what was last saved. Only what changed is sent. What starts something rather than storing a value has a button of its own that asks first: the Node.js version (it builds again), sendmail, and Delete, which comes last.

How the project is built and served (filled in from what the panel found in your files), its name, and Delete. The document root, the 404 page, the single-page switch and the start command apply to the live version at once (the start command at the next restart); the memory limit is a whole number of megabytes, or empty for half the server — anything else is refused with a sentence; the output folder and static-or-server wait for the next build, so the live version keeps being served as it was built until then. Deleting asks you to type the project's short id and removes its account, files, database, processes and web configuration — and its DNS records on Cloudflare that point at this server, unless you untick the box above Delete (the confirmation says which it will do). A record that points somewhere else is never touched.

Builds and memory (a Node.js website, a website made with Create with AI, and a static website with a build command). Beside the build command, This build needs about (MB) is what one build of the website needs: the panel plans the build's swap and its heap for that number from the start, instead of learning it from a build that ran out. It is not a limit — past the memory the server can give, the build uses swap and runs slower, and nothing stops it for that. It takes a whole number from 512 to 65536, or empty for what its last builds took. It is the same number build.memoryMb sets in the website's sixpanel.json (see A setup file in the repository: sixpanel.json below), and when the file says it, the file wins at every build, so the field shows the file's number and is changed there. A website of a limited account is still held to its account's memory, and what its build is planned for above that goes to swap. The card under the form says, in one line, what this server can give a build right now (the memory it is held to and the swap past it, the swap file it would add included) and whether the next build fits, will use swap, has no disk room for that swap, or, for a website of a limited account whose swap cannot be made, needs more than its account may hold; the next line says what the next build is planned for and why — the number above, the website's sixpanel.json, what its last builds took, or, for a website never built here, one large Next.js build. Then the last ten builds: when, how long they took, the most memory each held, what each was given (memory, the swap file, the heap) and how it ended — finished, out of memory, heap limit, failed, too slow or cancelled — each with View log. For a build stopped for memory, the panel's own sentence about it is under the list. A failed deploy's red card that says the build ran out of memory has a Build memory button that opens this card.

A Node.js, Python or Java website's Settings also have sendmail: off, its app may not hand mail to this server's mail server with the sendmail command; on is the owner's, asked with the risk — see Email → PHP mail() and sendmail.

Maintenance mode, on every kind of website. Press Turn on maintenance mode and every visitor gets a "back in a few minutes" page (HTTP 503 with Retry-After, so search engines and uptime monitors treat it as temporary), and anything that calls /api, or asks for JSON, gets the same answer as JSON. nginx answers it and your app is never asked, so it works the same for a static site, a Node.js, PHP, Python or Java app, WordPress and a reverse proxy. These still go through: the certificate check (renewals keep working), push-to-deploy (a fix can still arrive the usual way), and this server itself (the panel's own checks). Open the site opens a new tab that lets your browser past the page for an hour. Each press makes a new link, and turning maintenance on again makes a new pass, so an old one stops working. Turn off maintenance mode opens it to everyone again. While it is on, the Overview says so. The switch waits for an HTTPS address: until the website has one it serves no visitors. Tia can switch it too (ask her to "put the website in maintenance"; she asks you first), and so can SSH: sudo sixpanel site <short-name> maintenance on, off, open (prints the link) or status. A website moved to another server arrives with maintenance off. WordPress has its own maintenance switch on its WordPress page, which WordPress answers itself; this one is answered by nginx and covers wp-admin too.

A website is deleted at once — there is no seven-day window as there is for a 6amMart project — so the confirmation also says when the newest backup that holds it was taken, or that no backup holds it and nothing can bring it back. Back it up first on its Backups page if that is what it says.

On the copy of a website that was moved to another server, the DNS box starts unticked: the website still exists, and that record is the one you point at the server it lives on now.

Owner: give it to an account, or take it back

The Owner card on Settings says whose the website is (yours, or a reseller's or a user's account) and lists its last owners. Transfer website gives it to an account, takes it back, or moves it from one account to another. It stays where it is: the files, domains, certificates and live release do not change, and visitors notice nothing.

  1. Pick who it goes to and read the checks: room in the account's package, domain names, staging sites, a job still running.
  2. Read what is closed for the account that loses it (FTP and SFTP users, database and Redis passwords, the webhook secret, MCP tokens, SSH keys, a WordPress website's administrator password and salts) and what happens to the saved repository token, which stays unless you tick Remove the saved repository token.
  3. Type the website's short name and press Transfer. The dialog ticks each step. A step that stops leaves Finish it on the card.

A reseller sees this card for its own accounts' websites; a user does not. On the command line:

`sixpanel site <slug> transfer --to <usernameowner>`. Tia can do it too, after your yes on a card.

Every detail: Transfer a website and Accounts.

Move it to another server

A static website, a Node.js app, a PHP website and a WordPress site can be sent to another SixPanel server from Migration — one at a time on One project, or with everything else on Everything. It arrives with its files, its database, its addresses and their certificate, its settings, its scheduled jobs and where its code comes from, and both copies are compared before the other server keeps it. The copy here is then parked: kept whole, stopped, and marked on every page of it, with Start it here again as the way back. A website made with Create with AI and a staging site stay where they were made. The whole of it is on Move projects to another server.

Test on a branch, then promote

A website connected to git can be tested on a branch of its own before production gets the change: make a staging site with Work on its own branch ticked, change and test it there, and Promote — one job that backs up production's database, merges the branch, deploys production with its deploy commands and puts production back if any of it fails. Staging & Testing → Working on a branch and promoting has every step.

A setup file in the repository: sixpanel.json

A website's build and start commands, its Node.js, PHP, Python or Java version, the variables it needs, its PHP settings and its cron jobs can be written in a file at the top of its own files, sixpanel.json, the way vercel.json works on Vercel. Every deploy reads it — a git push as much as an upload — builds the new version with it, and applies it only once that version is live; a file that says something wrong stops the deploy before anything changes. The Overview shows which version's file is in force, what it set and which variables it still needs, and Check sixpanel.json shows what the next deploy would do without deploying. Cron jobs from the file are marked From sixpanel.json on Cron jobs, and can call an address of the website itself. Every key, an example for each kind and the rules are on sixpanel.json.

Deploy on every git push

Connect the repository on Deploys (Connect git). Automatic deploys (the last step of that window, and Set up automatic deploys on the page) turns it on — once the address answers over HTTPS, because the webhook arrives at the site's own address. Until then it says which is missing, with the button that fixes it.

Turned on, the panel first checks the address itself: it sends a signed test delivery to https://<your address>/.sixpanel/deploy, through Cloudflare, and says whether it was accepted (or that the certificate is one a git host would refuse). Then it shows the webhook address (https://<your address>/.sixpanel/deploy) and the secret, each with Copy, and the steps for GitHub, GitLab and Gitea / Forgejo — the tab of the forge your repository is on opens first, and Open the webhook page on GitHub (or GitLab, or Gitea) goes straight to the form. In short, add a webhook with that address, content type application/json, the secret, and push events:

  • GitHub — Settings → Webhooks → Add webhook.
  • GitLab — Settings → Webhooks; paste the secret as the Secret token.
  • Gitea / Forgejo — Settings → Webhooks → Add webhook → Gitea.

Only pushes to the branch you chose deploy; others are ignored. The card shows the last delivery, when it arrived and what came of it — deployed, deploying now, a deploy that failed, a push to another branch, or the forge's test delivery. A delivery with a wrong secret is refused, recorded on Activity, and the card asks for attention. New secret replaces the secret (paste the new one into the webhook straight away); Turn off stops deploying on push.

The window notices the forge's first delivery by itself. A private repository needs an access token with read access to it (GitHub: a fine-grained token with Contents: read) — or the website's deploy key, and then the git@… address works too.

A preview for every pull request

Deploys → Pull request previews gives every pull request its own staging site, with its own address, made from the pull request's branch. Open a pull request, and a minute or two later its address is written on the pull request; close it (merged or not), and the preview is deleted.

Before you start. The website is deployed from git, automatic deploys are on (above), and it is a kind that can have a staging site — WordPress, a Laravel app or a static website (Staging & Testing). In the forge's webhook, also send pull request events: on GitHub, Let me select individual events → tick Pushes and Pull requests; on Gitea or Forgejo, tick Pull Request beside Push. Nothing else changes — pull requests arrive at the same address, signed with the same secret, and a delivery with a wrong signature is refused.

Turn it on. Tick Make a preview for every pull request, then choose:

  • At most, at a time — 1, 2 or 3 (3 by default). One more waits on the card as waits for room, and is made by itself when another pull request closes.
  • Address — a free sixpanel.dev test address (from your AllsWeb plan; nothing to set up in DNS), or pr-&lt;number&gt; on the website's own domain, one label below the zone so Cloudflare's free certificate covers it: shop.example.com gives pr-12-shop.example.com, example.com gives pr-12.example.com. Each such name needs an A record to this server, proxied. The panel makes it when a Cloudflare account added to the panel holds the zone — for your own websites only: the preview of an account's website is the account's, and the panel never uses your Cloudflare for it. Otherwise make it where the domain is managed: one wildcard record (* in the zone, A to this server, proxied) covers every pull request. Until a preview's record is there, its staging site stops at Point the names at this server and its log names the record.
  • Write the address on the pull request — one comment on GitHub with the address, the state and how long the deploy took (Ready in 1m 52s), edited as it changes. It needs the website's saved access token with write access to pull requests; with a deploy key, or on another forge, the address is shown on the card only, and the card says why. On a public repository the comment says the preview is ready and how long it took, but never its address: anyone can read a public pull request, and a preview holds a copy of your website's data. You open it from the card.

What a preview is. An ordinary staging site of the website: its own account, folder and database holding a copy of production's data, mail kept in the log, scheduled tasks off (what the panel changes in a copy). A new push to the pull request's branch deploys its preview, as a push to a staging site's branch always does. Production is never touched.

A pull request from a fork waits for you. Its code is somebody else's, and a build runs it on your server — inside a staging site that holds a copy of your website's data, which that code can read — so it is never built by itself. You get a card on the bell, and the card on Deploys shows Build this commit. Saying yes builds that one commit: the panel copies it into your repository as the branch sixpanel-pr-<number> (this needs write access, as a staging site on a new branch does) and makes the preview from it. A newer push to the fork asks you again. When the pull request closes, its preview and the sixpanel-pr-<number> branch are deleted. A branch of your own repository is never deleted — it is its author's.

A website that is being moved to another server, or is still arriving from one, makes no preview until the move has finished.

On the card. Each pull request has its state — being made, ready, made, not started, deploy failed, waits for your yes, waits for room, not made (with the reason), deleted — with Open (the preview), Pull request and Delete. Delete deletes the preview's staging site and keeps the pull request on the card as deleted; its comment says the preview was deleted, not that the pull request closed. A preview you delete here, or whose staging site you delete on Staging & Testing, is not made again by the next push and no longer counts against At most; press Build to make it again. A preview whose job ended without the card hearing — stopped by the server's restart or an update of the panel, or cleared after six hours without a line — is shown as deploy failed (or not made, when its staging site was never made) the next time the card is opened, and at the panel's start; it no longer stays being made and blocks the next one.

Accounts. A preview counts as a website — and, when the website has a database, as a database — of the account the website belongs to, and runs inside that account's limits. A preview the account's package has no room for is not made, and the card and the pull request say which limit. The account sees the card; the owner of the server switches previews on and builds them, because a staging site is the owner's. An account's website uses pr-&lt;number&gt; on its own domain (a test address comes from the owner's AllsWeb plan). When the account is suspended, its websites' previews show the suspended page and start nothing, as its websites do, and come back when it is unsuspended. While it is suspended no new preview is made and nothing is deployed: the website's webhook address is the one path of a suspended website that still reaches the panel (every other path shows the suspended page), and the panel answers a pull request opened or pushed to, and a push, with refused (HTTP 409) before anything is copied, cloned or started. The repository shows the delivery as refused, with a sentence that names no account; Deploys → Automatic deploys shows it as refused — the website's account is suspended, and Activity records it as webhook-ignored, naming the account. A delivery with a wrong secret gets the same answer as on any website and learns nothing of the suspension. You can deliver it again from the repository's webhook page once the account is unsuspended. A closed pull request still deletes its preview.

When the website goes. Deleting the website deletes its previews with it, by every road (its page, Tia, an account's delete) — after the website stops answering, so no pull request can make one more, and none waiting for room is made in their place. Handing the website to another account (Transfer) deletes its previews and switches previews off: they were made for its previous owner. Each pull request's comment then says its preview was deleted and why, never that the pull request closed. The transfer's check list and an account's delete say how many previews go; previews never block either, as other staging sites do.

Tia and MCP read the card and can switch it on, build and delete; a fork's commit is built only after your own yes.

Changes on the server: commit and push

A file fixed on the server — on Files, over SSH, or written by the app itself — used to stay there until the next deploy put the repository's version back over it. The Changes on the server card on Deploys sends it back to your repository instead. It is yours, the server owner's: a reseller or a user does not see the card.

Which websites. A PHP website (its folder is the repository's files), a static website without a build command, and a WordPress website whose repository is one theme or one plugin (that folder is what is compared). A Node.js, Python or Java app, and a static website with a build, run what the build made from the repository, so a file changed on the server is not one of the repository's files: the card says so — change the file in the repository and deploy. A Create-with-AI website keeps its own history (Build with AI commits and pushes every change), and a staging site commits on its own Test copy page.

What it shows.

  • The repository and branch the website reads, and Change git connection.
  • Every file the live folder added, changed or removed since the commit that is live. Show the change opens that file's changes line by line. What an app or a package manager writes (vendor/, node_modules/, storage/, uploads, caches, logs) is never offered.
  • Never committed — files that look like secrets: .env and every .env.*, *.pem, *.key, SSH keys (id_rsa, id_ecdsa, id_ed25519), *.p12, *.pfx and other key stores, auth.json, wp-config.php, .htpasswd, .npmrc, .netrc, .pgpass, .my.cnf and .git-credentials — and any changed file that holds one of this website's own passwords (its database's or its Redis's), whatever it is called. Each is listed with why, is never shown, and never leaves the server.
  • A commit message worked out from the files — edit it if you like — and a tick beside each file, so you can leave one out.

Commit and push makes one commit on top of the live version and pushes it to the connected branch. A push is never forced. When it lands, the live version is that commit, so the push starts no new deploy — the webhook delivery for it is recorded as already live, and nothing is put back over the website's files.

When the branch has newer commits (someone pushed from elsewhere), nothing is pushed and the card lists them. When they change other files than yours, Pull first merges them with your commit, pushes the merge and deploys it. When they change the same files, there is no Pull first: merge them in the repository.

When the branch was moved back or deleted after the live version went live, nothing is pushed: a push from here only adds to a branch, so a commit someone took off it never comes back this way. Deploy the branch, then make the change again. If a deploy starts on the website while a push is running, the pushed commit is deployed after it instead of being counted as live.

When the git host refuses, the card says why and what to change there:

  • A read-only deploy key — GitHub: Settings → Deploy keys; remove the key and add it again with Allow write access ticked (GitHub cannot change that on a key already added). GitLab: Settings → Repository → Deploy keys; tick Grant write permissions to this key. Bitbucket's access keys can only read: add the key to an account that may write, or use an access token with Repositories: Write.
  • A read-only token — GitHub: a fine-grained token with Contents: Read and write. GitLab: a token with the write_repository scope. Bitbucket: a repository access token with Repositories: Write. Save it with Change git connection.
  • A protected branch — allow this server's key or token to push to it, or connect a branch that is not protected.

Open the repository's settings goes straight to the right page.

Only the owner of the server sees this card. A temporary login and the demo are refused, and every push — pushed or refused — is a line on Activity.

Change git connection

Change git connection opens the Connect git window with the saved repository, branch and way in filled in. When the host refuses, the window says what to set up on GitHub, GitLab or Bitbucket — the deploy key's page, the token's scope — and a branch that does not exist is answered with the ones that do.

A new repository or branch keeps the one the live version came from. Until a deploy from the new connection goes live, the card offers Go back to it, and says it plainly when that first deploy failed: visitors still get the version from the old connection, and one press connects it again (nothing is deployed — the live version already came from there). Meanwhile the live files are not offered for a commit: they are the old repository's, and must not be pushed to the new one. Changing only the token or the key keeps everything as it was.

What a temporary login can do

A temporary login (Share access) can deploy, build, roll back, restart, purge the cache, edit files, change a website's Web Rules, run and edit scheduled tasks, update WordPress and its plugins, deploy a WordPress theme or plugin, take restore points, and turn a website's PHP mail() and sendmail off (never on). It cannot see or change secrets — environment variables, the database password, the git token, the deploy key, the webhook secret, .env and wp-config.php — and it cannot create or delete projects, change addresses, restore over the live database, put a website back from a backup, see or push the changes on the server, change the git connection, or use your AI provider keys.

A reverse proxy is the owner's alone: a temporary login can test it and look its name up again, and change nothing on it.

How to check it worked

  • The project's card on Projects says live, and Overview → Open the website opens it over HTTPS.
  • Overview shows the version you just deployed, and Deploys → Live now names it and says since when.
  • For a Node.js app, Logs → the app's output shows it started without errors.

If it went wrong

  • "The setup of this website did not finish". The create job stopped half-way. Press Finish setting up on the card — see Create one. If it stops again at the same step, View log says why (the database server not running and a full disk are the usual two; Server → Health names both).
  • The build failed. Deploys says where it stopped, and View log shows the whole log; the site kept serving the previous version, with its own settings. Fix the source, or the command on Settings, and deploy again.
  • "…and the kernel stopped the build". The build needed more memory than the server could give it, and the kernel stopped it. The panel and your live sites keep running: a build is the first thing the kernel takes back, before the database or a site that is serving. The sentence says which case it was, with the kernel's own counters (the build's memory.events), the most the build held, its MemoryHigh and MemoryMax, and the least swap that was free while it built:
  • every swap slot was used — the next build of the site is planned for more and given the swap for it, so deploy again; if the disk has no room for that swap, the sentence says to free disk space;
  • swap was still free — memory filled faster than the kernel could move it to swap; deploy again when the server is quieter;
  • the account's memory limit — a website of a limited account built into its package's memory limit; raise it on the Accounts page first. A build is given swap for what it is planned for above its account's memory, so this is a build that had no swap left to go to: it used all the swap it may hold, or the disk had no room for its swap file. The panel ends such a build itself, about half a minute after it reaches the limit, and the sentence says so: it never waits there until its deadline. When the limit was its reseller's (a user with no limits of its own), the sentence says the reseller's memory limit: raise the reseller's package. A build that V8 stopped at its heap says so too, and the next one gets a larger heap. When the process that stopped was well below that heap (a Next.js static-generation worker, which gets Node's own heap of about half of MemoryHigh), the sentence says a larger heap cannot help it and the next build is planned the same: deploy again when more of the server's memory is free. The panel says "add memory or swap" only when the server had no swap to spare.
  • A PHP website's deploy failed and the site shows errors. A PHP website is updated in its own folder, so a deploy that fails after the files were copied leaves the new files serving — without the database changes that were to follow. (The packages are the previous, complete set: Composer builds the new ones beside them and only a finished set is swapped in.) Deploys says which it is. Fix the cause and deploy again; to go back, Backups puts an earlier version back.
  • "a web server cannot serve from a name like that". The page the site starts from is in a folder whose name has a space or another character nginx cannot carry. Rename the folder with letters, digits, dots, dashes and underscores.
  • The app starts but the page shows an error. Check Environment against .env.example, then Logs.
  • "Access denied" from the database in a Node.js app. Use DATABASE_URL or DB_HOST as the panel sets them — a hand-typed host or password does not match.
  • The address does not open. Domain & SSL says what is missing; see Domain and SSL and Cloudflare.
  • "…points straight at this server, and this server is set to refuse visitors that do not come through Cloudflare". Cloudflare → "Refuse visitors that skip Cloudflare" is switched on, so an address whose DNS goes directly to the server would answer nobody — the panel stops before the certificate rather than finish with an address that is dark. Put the address behind Cloudflare with the orange cloud on and connect again, or switch that row off.
  • A push did not deploy. Deploys → Automatic deploys shows the last delivery. A push to another branch and a wrong secret are the usual answers; the repository's webhook page shows the response too.
  • Your git host shows a refused delivery saying "this website's account is suspended". The account the website belongs to is suspended, so the push deployed nothing (and a pull request made no preview). Once the account is unsuspended, send the delivery again from the repository's webhook page.
  • Your git host shows a failed delivery saying the website "was moved to another server". The address still points at the server the website was moved away from, whose copy deploys nothing. Point the address at the server it lives on now and send the delivery again from the repository's webhook page.
  • "… was moved to …, and this copy is stopped" or "… is being moved to another server right now". See Move projects to another server: the first is a parked copy (Start it here again on its Overview brings it back), the second passes when the move ends.

The software card on this page

A website's pages show the cards of what that website uses: its Cache page its Redis, Memcached and Varnish, its PHP page the PHP-FPM it runs on (and Apache when it uses it), its Database page its database engines and Redis, its Overview the Node.js, Python or Java it runs on, or Docker. Restart on its Redis restarts that website's Redis only. It is the same card as on Software: its state, its version, a waiting update and, for the owner, Restart (asked first, and it waits for any job that is running). On Software opens its card there, with who else uses it. See Software, search and the system monitor.

Something unclear?Ask Tia