Changelog

Agent teams. When a change looks consequential, Helix can call in specialist agents to review it in parallel — one for security, one to check the tests actually pass, one to find what else the change might break — and then reconcile their findings before it finishes. Three independent angles on the same change, instead of one model's opinion.

Your call on how much help Helix brings in. Settings now has a switch for reviewing changes, a switch for exploring a dead end in parallel, and a switch for sub-agents — so you can keep runs lean on a small edit and turn everything on for a risky one. A setting your workspace has turned off always wins, and Helix tells you when that is why.

Analysis you can trust. When the useful output of a run is numbers — a report, a spreadsheet, a notebook — Helix now sends a second agent to recompute them from the source data and check they add up. It looks for figures that were typed in rather than calculated and for charts whose labels do not match the data, and reports honestly when a number cannot be reproduced.

Parallel work costs no extra environment. When Helix explores several ideas at once, each gets its own isolated copy of your project on the same machine, so asking three questions does not mean three setups.

Build your own agents. You can now create agents for your team, each with its own instructions and its own limits — an agent that reviews billing code and may only touch the billing directory, for example. An agent's scope is enforced, not just described, so it cannot reach past what you granted it.

Clearer agent reports. When one agent hands work to another, the handoff is now structured: what it found, what it checked, and how confident it is. A finding without evidence is reported as unverified rather than presented as fact.

Agents work in their own isolated copy of your project, so one agent exploring an idea can never overwrite your files or leave a stray change behind. Everything they find is advice you can act on — they never edit your code themselves.

An agent can never act with more authority than the run that started it. If your plan or your balance limits what Helix may do, anything it delegates inherits the same limit.

Helix no longer offers you tools your plan does not include. Previously it could suggest an action it would then decline to run, which read as a broken feature rather than a plan limit.

Search engines now get an accurate "last updated" date for each page instead of today's date for every page, so pages that actually changed get re-crawled first.

Helix no longer stalls when a response is cut off before it takes an action. It recovers in one step instead of retrying the same way and burning the turn — the most common cause of a run going quiet mid-task.

Everyday steps now think more efficiently, so runs move faster and use noticeably fewer tokens for the same result. Deep reasoning is kept for planning, where the extra thought is worth it.

When a request is ambiguous, Helix asks before acting — and offers the likely readings as one-click answers, including an option to investigate and explain the trade-offs when you are not sure.

Runs no longer lose track of a task list when Helix is reading rather than editing, so progress shown against the plan matches the work actually done.

Workspaces survive a long pause. Coming back to a session the next day resumes the same environment instead of starting from an empty project.

Self-healing runs. When Helix hits a recoverable snag it now works through it and carries on, instead of stopping and waiting for someone to press resume. Genuine dead ends still stop and tell you why.

Undo for destructive steps. Before anything irreversible — a force-push, a schema change, a production deploy — Helix opens a restore point first. If the step turns out to be wrong, the run can be reverted to where it was.

Multi-repository workspaces. Point Helix at several repositories at once and it clones and reasons across all of them, so a change that spans a frontend, an API and a shared library can be made in one run.

Project memory. Helix keeps what it learns about your codebase — conventions, decisions, past incidents — and recalls it in later sessions, so you stop re-explaining the same context.

Document upload. Drop in a spec, a PDF or a design doc and ask Helix about it. Long documents are read in paged chunks so a large file can't crowd out the rest of your conversation.

Blast-radius-aware autonomy. Helix stays fully autonomous on ordinary code edits and only pauses for confirmation on genuinely irreversible operations, so autonomy stops feeling fragile.

Better memory under long runs. Key facts — your goal, recent follow-ups, paths, ports and background job ids — are carried forward through long conversations instead of being summarised away.

Answering a question now ends in the strongest available model, and a plain question costs no credits — advice is free.

Stopped and interrupted runs no longer jumble their activity in the timeline. Events always appear in the order they happened.

Large file writes no longer get cut off mid-write, and editing a file no longer loses its unedited region.

Quiet by default. Tool calls, reasoning and finished output fold away, and the one step Helix is actively working on stays open. You can open anything, and your choice sticks.

Responses now stream as they are written, so you can read along instead of waiting for a completed answer.

One-click answers. When a request is genuinely ambiguous, Helix asks a specific question with the likely interpretations as buttons. If you don't know, there's an option that has it investigate and recommend instead.

Tool output is rendered as readable text — command output under its own heading, structured results as proper JSON — rather than raw payloads.

Runs that hit a rough patch with a model provider now pause and can be resumed, instead of failing outright.

Progress notes no longer duplicate, and a refreshed page rebuilds the full activity history correctly.

Helix is the new brand. The product is no longer positioned as a PaaS or cloud provider; it is an autonomous AI software engineer that can code, test, debug, open PRs, and deploy to any connected cloud provider.

Rebuilt marketing pages for the Helix positioning, including the landing, support, and changelog experiences.

Helix context handling: tool output is truncated and summarized when it gets large, long conversations are condensed, and oversized outputs can be offloaded to the sandbox so Helix keeps reasoning without hitting model context limits.

Framework-aware pre-PR validation. Helix now detects Node, Python, Go, Rust, Java, Ruby, PHP, and .NET projects, runs the right test, lint, typecheck, and build commands, and can add missing scripts when the config is present.

Self-recovery on publish failures. If a PR, build, or publish step fails, Helix sees the error as an observation and retries with a corrected plan instead of giving up.

Usage and billing counting is now wired through team credits and per-day, week, and month Helix quota checks for queries, sandbox compute seconds, and provider API calls.

Helix connects to your infrastructure via secure SSH to run diagnostics, restart services, and fix config issues directly in your running containers — no manual intervention needed.

Autonomous troubleshooting: when builds fail, Helix reads the logs, diagnoses the root cause, and applies fixes automatically based on your configured trust level.

Direct shell access empowers Helix to perform advanced operations: log rotation, service restarts, config updates, and container-level debugging.

SSH credentials are managed securely through environment variables — Helix provisions and rotates access autonomously.

Watchdog mode: Helix runs continuously in the background and springs into action when issues arise, working autonomously at your configured trust level.

Forge builds are hardened end-to-end. Every repository clone now runs in a fully isolated, shell-free pipeline with strict validation of branch names and repository URLs — closing off an entire class of injection attacks before a single byte of your code is fetched.

Tighter tenant isolation for Helix. Your AI copilot's memories, suggestions and project context are now locked to your account and team at the database level — nobody outside your workspace can ever read or write them.

Role-aware environment variables for Smart Groups. Shared group env vars — which flow straight into your deploys — can now only be created or changed by Owners and Developers. Viewers keep read access, exactly as you'd expect.

Every dependency across the platform audited and patched — zero known vulnerabilities in our production dependency tree.

The pricing page now reflects the platform you actually use today: LaunchVerse Forge builds, zero-config framework auto-detect, accelerated build caching, instant image rollback, and the full Helix AI copilot tier breakdown — conversational chat limits, live log streaming, and deploy & rollback actions per plan.

Faster, leaner platform under the hood — the framework and build toolchain were upgraded to their latest secure releases across the board.

The legacy first-generation build runners are fully retired. Forge — our own build engine — now powers 100% of builds, previews and rollbacks on LaunchVerse.

Smart Project Groups are here. Transform your isolated apps into a cohesive ecosystem. Group your frontends, backends, and databases together and the Launchverse Engine will automatically wire them up on a secure, private network — no complex firewall rules needed.

Zero-config internal networking. Apps inside a Smart Group receive clean, predictable internal DNS names based on their project names. Your frontend can securely talk to your API internally without ever exposing traffic to the public internet.

Automated Secret Injection for groups. Define shared environment variables once at the group level, and Launchverse automatically injects them into every app in that group during deployment.

Dependency-aware deployments. Hitting 'Deploy Group' triggers a coordinated rollout. Launchverse restarts databases first, waits for them to become healthy, and only then deploys the downstream applications so your apps never boot up before their dependencies are ready.

Visual Project Canvas support for groups. Your project canvas now intelligently maps out group architectures. See your entire microservice stack mapped out visually with routing edges, and jump instantly to peer apps within the same group.

Meet Forge — the Launchverse build engine. Forge builds your app on our own infrastructure with framework-aware build recipes and lockfile-accurate installs for npm, pnpm, Yarn and Bun, plus first-class support for modern edge targets like Cloudflare Workers. It's the same engine behind both your production deploys and your PR previews, so what you preview is exactly what ships.

Start a 14-day free Pro trial in one click. A new banner on your dashboard unlocks Pro limits and features for two weeks — no card required. It activates instantly and reverts on its own when the trial ends.

Installs are auto-detected, never forced. Leave the install step blank and Forge picks the right lockfile-aware install for your project — with a safe fallback — instead of assuming npm. Your own typed command always wins.

Environment variables added while creating a project now reach your very first build and the running app — no extra redeploy or restart needed.

Clearer pricing. Every plan card now spells out concurrent deploys, PR previews and the exact capabilities each tier unlocks, so the value of upgrading is obvious at a glance.

Branded link previews. Sharing a launchverse.app link now renders a polished card featuring the product dashboard.

Successful deploys now glide straight to your project overview right after the celebration, so you land where the action is.

The repository picker now shows just the repo name for faster scanning when you start a new project.

Crisper deploy thumbnails. Preview screenshots now wait for your site's certificate to go fully live before capturing, so the thumbnail is your actual app — never a browser security screen.

Projects with unusual repository names — trailing dots, spaces or special characters — now build cleanly instead of failing with a naming error.

Our first-generation build runners are being retired. Every build now runs on Forge; the legacy runner pool is deprecated and winding down. No action needed — your projects already build on Forge.

Build minutes are now metered to the exact second instead of rounding up to the next whole minute. A 12-second build counts as 0.2 minutes, not 1 — your usage reflects real compute time and your monthly quota counts down precisely.

The public site has a brand-new look. The landing and every marketing page now share the dashboard's graphite-and-gold design system, with a flat full-width header, premium motion, and a focused product page that leads with real screenshots of the actual product instead of mockups.

The product page now showcases real platform surfaces — the one-click marketplace, in-dashboard domain purchase, and bring-your-own-server deployments — each with a live screenshot straight from the dashboard.

Fixed a rendering glitch where pages with frosted-glass panels could show horizontal banding or tearing on some phones and tablets. Backdrop blur and other GPU-heavy compositing effects are now disabled on touch devices and replaced with solid surfaces, while desktop keeps the full glass look — smoother scrolling and no visual artifacts on mobile.

Helix AI Copilot is now embedded across the deploy experience. When a build fails, Helix explains what broke in plain English, shows ranked fix suggestions with confidence scores, and can apply the patch as a PR to your repo — without leaving the dashboard.

Multi-turn conversation with Helix. Ask follow-ups, dig deeper into a specific error, or request alternative fixes — Helix remembers the full conversation within a session, including what it suggested before.

Helix remembers your project. The assistant reads your project's framework, language and recent memory across sessions — so repeat advice, getting-started tips and recurring error patterns don't need re-explaining every time.

aiAssist quick-launch. Add `?aiAssist=1` to the deploy wizard URL and Helix opens automatically on mount — useful for deep-linking from error pages, CI notifications or our build-failure email.

Cross-session restore. Open a deploy wizard with a session ID and Helix picks up exactly where the previous conversation left off — messages, context, suggestions, everything — so a troubleshooting session survives a page refresh or a return visit.

Build Pipeline V2 is live — builds now run inside isolated containers with images pushed to a private registry and swapped into production atomically. Resilient to repos without lockfiles, missing remote refs, and Dockerfile vs zero-config auto-detection.

New login and signup screens with a playful split layout — animated illustrations on the left, a clean form on the right — designed mobile-first and optimised for touch.

Default-branch detection now falls back gracefully when a repository has no remote HEAD ref, and build-time env-var injection no longer drops variables during the build.

The instant-build pipeline correctly pushes images to a registry namespace the deploy token can write, and the build validator accepts first-party Dockerfile templates without false rejections.

Deploy logs are now cleaner and scroll within a fixed-height container — removed terminal chrome and rounded-corner styling, and capped the log view at 55vh so the build output scrolls inside the container instead of pushing the rest of the page down.

Auth pages now show a subtle mobile flourish on the form — animated input focus rings, smoother transitions between signup and login, and a more prominent password-recovery entry point.

Build Pipeline V2 Dockerfile templates gracefully handle repos without lockfiles, auto-detecting the package manager from the codebase and falling back to `npm install` with forgiving defaults.

Tier-downgrade now warns you before touching your databases and services. Pick which attached resources to keep, archive or delete before the downgrade completes — no more surprise state mismatches.

Deploy hooks now reliably respect the force flag. Kick off builds from CI/CD pipelines or webhooks with confidence — the build cache reuses properly and GitHub receives the right completion status every time.

Domain syncing now hits the correct Launchverse deployments endpoint. Custom domains stuck in 'syncing' finally resolve, and we fall back cleanly when no terminal state is found.

Failed deploys now show clearer error context in the dashboard, making troubleshooting faster before you reach for the build log.

PR Previews are back. Every open pull request on a connected repo now gets its own fully-isolated preview environment with a unique URL — survives across pushes, persists for 24 hours after the PR closes, and tears itself down automatically afterwards. The Previews tab in your project shows live URL, status, last commit, and a one-click 'Promote to production' for the build you've signed off on. Available on Student, Pro and Enterprise; Free plan stays on production-only auto-deploy.

Promote a preview build to production with one click. Open the preview in the Previews tab, hit 'Promote to production', and we re-deploy the exact commit that built green in the preview against your main project — no rebuild loop, no copying env vars, no manual git push. The promoted deployment streams progress in realtime exactly like a normal push deploy.

Rollback, redeploy and promote-to-production now stream their progress in realtime — same SSE feed, same Deployments row, same email-on-finish, same Cancel button as a regular git-push deploy. Previously rolling back to an older commit would kick the engine off into the background and your dashboard would stay stuck on 'Deploying' until the next page refresh; now every status transition lands within a second of the engine emitting it.

Environment-variable changes that trigger an auto-redeploy now show up in the build feed too. Edit a var on the Environment tab, the project rebuilds, and the resulting deploy gets a row in Deployments with SSE logs, status pill, email-on-finish and a working Cancel button — same first-class treatment as a push deploy. Before this the rebuild happened silently in the engine.

Cancel works on every kind of in-flight build now — push, manual redeploy, env-var-triggered rebuild, rollback, promote, and PR-preview build — including the freshly created PR preview environments. We canonicalise the engine URL, look up the right engine app uuid for the preview, encode it correctly in the cancel call, and bound the request to 8 s so a flaky engine response can't strand your project on 'Cancelling'.

PR-preview builds on private repos no longer fall through to a public clone path. We now resolve your team's GitHub-App source uuid for the parent project and pin every preview app to it — so the engine has the same installation credentials your production deploy uses. Builds that used to 404 at `git ls-remote` now clone cleanly.

AI-Explain's 'Apply suggested fix as a PR' now distinguishes the two ways GitHub can deny the write. If the Launchverse GitHub App isn't installed on the repo you get a 404 with the exact install URL inline so you can fix it in two clicks; if the installation is there but the scopes are wrong you get a 403 with the scope you're missing. Previously both presented identically as a generic 'denied'.

New per-project setting: 'Auto-close idle previews after N days'. Opt-in inactivity GC for PR previews — if a preview goes that long without a new push, we flip it to `closing` with the same 24-hour grace window the PR-close path uses. Push to the PR head branch at any time to revive a flipped preview. Default is 0 (disabled) so nothing changes for projects that don't opt in.

Coupon expiry now honours calendar months. A 'three month' grant redeemed on May 15 now expires on Aug 15 instead of 90 calendar days later, matching how users actually read 'three months from today'. Existing day-based coupons continue to work unchanged; pick `durationMonths` or `durationDays` per coupon code.

Usage page now shows two distinct dates: 'Quota resets on …' (your monthly build-minute / bandwidth / storage rollover, anchored to your billing day) and 'Plan renews on …' / 'Coupon expires on …' (when your tier itself flips). Previously the rollover date was hidden whenever a coupon was active, leaving users to wonder if their build-minute counter would refresh during the grant window.

Successful production deploys now PATCH your GitHub repo's homepage to your live launchverse.app URL. The deployed link shows up on the repo's About sidebar on github.com the same way Vercel / Netlify surface it. We respect any custom homepage you've already set — only empty values or *.launchverse.app URLs get overwritten.

First-time onboarding tour. Brand-new users now see a friendly four-step walkthrough on the dashboard pointing at where to deploy, where to find templates, and how to read your build feed. Skippable, never shown twice, never shown to returning users.

Six new starter templates: SvelteKit, Astro Starlight (docs), NestJS, Hono.js, Strapi v5 and Payload CMS. Fork in one click, import into the deploy wizard, and you're live in under a minute.

Auto-rollback is now per-project configurable. Opt out from the project settings if your API legitimately serves 5xx on health probes, set a custom probe path, and we'll honour a 30-minute cooldown so a single bad commit can't rollback-loop you.

Mutating endpoints now accept an Idempotency-Key header. Retry the same request inside 24 h and you get the cached first response back instead of a duplicate side effect. Same pattern as Stripe and Twilio.

Critical Postgres hardening: SECURITY DEFINER functions now pin search_path and the platform incidents table has RLS enforced. Zero user impact, just less surface area for anything that finds its way past the front door.

Cron jobs now hold a distributed lease before running. Vercel's occasional duplicate cron firings can no longer cause two copies of the same sweep to race the same row. Every cron also pings a heartbeat so we know within a minute when something stops firing.

Weekly automated database backups with a self-verifying restore drill. A backup we've never restored isn't a real backup; the drill restores into a throwaway Postgres and compares row counts against production.

Paystack webhook user-lookup is now O(log N) on the indexed email column instead of paginating up to 4 000 users per event. Inaudible win for now but unblocks 10× growth.

Launchverse Community is live. Publish your deployed projects, get upvotes and threaded comments, and follow what other builders are shipping — all without leaving the dashboard. Each post has its own immersive detail page (Overview, Comments, Stack, Updates) and is shareable as a public link: anyone with the link can read; signing up is required to vote, comment or post.

Project Canvas is here. Every project now has a Canvas tab showing your services, databases, domains and source as a live network of connected nodes — drag to rearrange, traffic flows along the wires, edges colour-code env-var references, attached domains and source links. Same architecture-diagram language as the marketing page, with your real services in it.

Profile got a major upgrade. Add a bio, link your GitHub, X and Bitbucket, and upload an avatar — anything you set shows up next to your community posts and comments. Designed mobile-first so the form is fully usable on a phone, including reaching the Save button above the keyboard.

Framework logos in place of plain text labels. The dashboard, projects grid and overview now render the actual framework logo (React, Next.js, Vue, Svelte, Astro, Remix, Nuxt, Vite, Express, Fastify, Django, Flask, Rails, Laravel and more) instead of the framework name as a string. Falls back to the text label gracefully for less-common stacks.

Live HTTP traffic panel on the Observability tab. See the last 60 seconds of requests as they happen — total volume, GETs, blocked, and errors — plus method-distribution bars and the top requested paths. No third-party SDK, no extra cost, no setup.

HTTP request logs are now structured. Method, path, status and duration line up in fixed columns, status pills are colour-coded by class, and methods are tinted by verb. JSON, Caddy/Pino and nginx/morgan formats are auto-detected; build-tool output stays raw.

Mobile menu redesign. On phones the navigation now slides up from the bottom as a sheet you can drag down to dismiss, instead of a side drawer — friendlier on the thumb, easier to scan, and one tap away on every dashboard page. Tablet and desktop sidebar are unchanged.

Profile is now visible in the Account section of the sidebar (mobile and desktop). Previously it was only reachable from the avatar dropdown — making it awkward to find on phones.

Deploy preview screenshots no longer get stuck on a 403 from the platform-hosted subdomain. Capture now races the custom domain and the platform subdomain in parallel, requires two stable success probes ≥ 4 s apart, treats transient 403s as 'still warming up' rather than a hard failure, and waits up to 90 s for slow first boots. Cached placeholder screenshots are evicted on rollout.

PR Previews are temporarily paused while we land an upgrade to the build pipeline. Pull requests opened on connected repos are still tracked on Launchverse and surfaced in your Deployments tab as Skipped — production auto-deploy on push remains unaffected. The Previews tab and the toggle in Settings → Engine are visibly marked Coming Soon. We'll roll the feature back on tier-by-tier and email you when your project is eligible again.

Claim a domain from another account. If you previously verified a domain on a different Launchverse account, you can now prove ownership with a one-time TXT record (`_launchverse-verify`) and transfer the domain to your current project. We email the previous owner the moment the transfer lands so it's transparent on both sides.

Provisioning a managed database no longer fails with `Engine Error: Server not found.` when a project's stored target server has drifted from the engine. We now validate the target against the live server list and fall back to the first registered server, mirroring how marketplace service provisioning has always worked.

Marketplace services (n8n, WordPress, Ghost, etc.) now actually start after provisioning instead of sitting in a created-but-empty state. We deploy the service immediately after creation and surface the assigned URL on the project's Resources page so you don't have to dig for it.

Deploy preview screenshots no longer capture a 'no available server' placeholder when you've just attached a custom domain. Capture now prefers your platform-issued `*.hosted.launchverse.app` subdomain — which has been routing since the very first deploy — over a freshly-attached custom domain that's still wiring up TLS and DNS in the background.

Project Overview no longer mislabels a closed PR's commit as if it were the live build. The Overview's 'latest deployment' card is now scoped to production deployments only — closed PR rows stay where they belong.

Mobile top bar is less cluttered. The cart icon was duplicated between the top bar and the sidebar drawer on phones — we removed the top-bar copy. Cart is still one tap away via the side menu.

Domains page is clearer about which DNS record to add. Subdomains like `app.example.com` get a CNAME pointing at the platform proxy (correct per DNS spec). Apex domains and wildcards get an A record (also correct — RFC 1034 forbids CNAME at apex). We surface this distinction up-front so you don't have to wonder why a CNAME field appeared instead of an A field.

Observability now lives on its own project tab with real telemetry — deploy success rate, build minutes consumed, container status from the engine, and a 30-day reliability histogram. When the platform's metrics agent is enabled, live CPU and memory time-series render in the Sentinel panel; when it isn't, we say so honestly instead of drawing synthetic graphs.

Security tab replaces the old firewall card with a real configuration surface — HTTPS enforcement, basic-auth gate, and an editable egress allowlist that names every host your container is permitted to call. The tab pulls live state from the engine on every load.

Cron jobs are now editable. The pencil icon on any scheduled job lets you change its name, schedule expression, or command — the change propagates to the engine immediately. Both the global Cron Jobs dashboard and a new project-scoped section on the Overview tab support this.

12 new in-depth guides for African and global developers: deploying Next.js without Vercel, provisioning managed Postgres, scheduling cron jobs, setting up 2FA, custom domains with free HTTPS, observability without Datadog, Postgres vs MongoDB in 2026, self-hosted vs managed databases, zero-downtime deployments, when to use Redis (vs DragonFly / KeyDB), web app firewalls and egress allowlists, and Dockerfile vs zero-config builds.

Two-factor authentication is now clearly available on every plan including Free. The copy on the Profile page no longer suggests it's gated to Pro / Enterprise — TOTP enrollment has always worked for everyone, the wording was misleading.

Project Resources page surfaces every credential, internal URL, external URL, and public port for both managed databases and marketplace services. For services we expose generated env-var credentials (admin tokens, passwords, API keys) without forcing you to copy them off the post-provision toast.

Project tab navigation now responds instantly with no skeleton flash. We removed the loading boundary that was painting a placeholder between clicks; tabs now behave like a regular link — old page stays visible until the new one is ready.

Provisioning a Postgres database no longer fails with `Validation failed - clickhouse_db`. The engine payload now wires only the field name that matches the engine you picked — postgres_db for PostgreSQL, mysql_database for MySQL, mariadb_database for MariaDB, mongo_initdb_database for MongoDB, clickhouse_db for Clickhouse.

Deploying a marketplace service (n8n, WordPress, Ghost, etc.) no longer hits a database constraint violation. The project_resources table now permits any engine-supported resource type and disambiguates databases vs services via a new `kind` column, with existing rows backfilled automatically.

Dashboard layout no longer jumps horizontally when a scrollbar appears. The container reserves its gutter up front so wide content stays put as it grows past the viewport.

Firewall links no longer 404. The old `/project/[id]/settings/security` deep links pointed at a route that didn't exist; the new Security tab is reachable directly from project navigation.

Helix — the new in-product assistant that triages your failed deploys. When a build fails, click "Ask Helix" and get a plain-English summary of what broke, the most likely root cause, and ranked fix suggestions, each with confidence scores and concrete patch snippets.

Deeper analysis mode pulls the relevant files from your repo (next.config, package.json, the file the error mentions) and includes them in the bot's context for higher-confidence patches.

One-click "Apply via PR". When the bot's patch looks right, hit Apply — it pushes a new branch on your repo and opens a pull request titled with the fix. Review the diff, merge, redeploy. No copy-paste.

Daily bot caps that scale with your plan: Free 5/day, Student 25/day, Pro 200/day, Enterprise unlimited — typical resolution costs us pennies per failed build, so we don't paywall the obvious help.

Build logs and repo files are aggressively redacted before they leave your project: GitHub PATs, AWS keys, JWTs, Bearer tokens, scheme://user:password@host URIs, and any *_KEY=, *_SECRET=, *_TOKEN=, *_PASSWORD= assignments are stripped server-side.

Project navigation is now genuinely instant. Tab clicks register on the first tap with no perceptible delay — we removed an architectural seam in the layout that was forcing React to re-evaluate the server boundary on every click.

Layout no longer shifts horizontally when content grows past the viewport height. Pages with content longer than the screen used to jump sideways the moment the scrollbar appeared; the gutter is now reserved up front.

Comprehensive glass-card pass across every page. Cards are tighter, less padding-heavy, and visually consistent — same blur, same shadow, same radius across project, dashboard, marketplace, and settings.

Logo, breadcrumbs, and back-arrow are now persistent on every project subpage so you always know where you are and how to get out, even three levels deep in settings.

Every deploy now reserves a slice of the host's CPU and memory before it kicks off. If the box is full, you get an immediate, friendly message instead of a build that quietly OOM-kills mid-way and asks you to retry.

Fair sharing across plans. Free-plan workloads never starve paid teams, and Enterprise can use the whole host when the box is otherwise idle. Each plan has a published share of the cluster — Pro gets up to 60%, Enterprise can go up to 100%.

Build queue. When the host is genuinely full, your build joins a FIFO queue rather than getting rejected outright. The dashboard surfaces your position; the queue drains automatically as capacity frees up.

Capacity reservations are released the second your build finishes — success, failure, cancel, or skip — so the next user's deploy can start in seconds. A safety-net sweeper additionally reclaims any reservation orphaned by a dropped engine event.

All four ways of starting a build — the Deploy wizard, manual redeploy, rollback / promote, and the external deploy hook — now go through the same admission gate. There's no longer a side-door that lets a script bypass your plan limits.

Rapid-fire pushes to the same branch now release the previous build's capacity slot the moment they cancel it, so the new commit starts immediately instead of waiting for the next sweep.

GitHub webhook deliveries are now deduplicated by their delivery ID. If GitHub retries because of a transient network blip, we acknowledge the replay with 200 instead of triggering a second build that would double-charge build minutes.

Subscription rows once again persist on every successful payment. A subtle schema mismatch was rejecting them silently — paid teams kept their plan, but the audit trail behind it didn't write. Both the live insert path and the schema constraint are now in sync.

External deploy-hook calls now stay inside your plan's concurrent-deploy cap. The hook used to slip past the limit because of a missing column join — pipelines that hammered the URL could starve the rest of the team.

Cancel button now reliably cancels in-flight builds across every status, in any spelling. Builds that were caught between provisioning and running are no longer stranded.

The capacity sweeper, queue drainer, and notifications retention job now run on their own schedules, so admission decisions don't have to wait for an unrelated cleanup pass to finish.

Build minutes are now billed from the moment your build actually starts, not the moment it joined the queue. Even if your project sat behind another team's deploy for two minutes, your minute counter no longer starts ticking until your build does.

If a build event ever goes missing in transit, we now safely cap that single deploy at your plan's monthly build-minute ceiling instead of rounding up to a worst-case fallback. Free-plan teams in particular can no longer accidentally drain their whole monthly quota on one stuck job.

Plan-tier CPU and memory limits are now enforced on every deploy. Pro projects always get their full container budget, Free projects always stay inside theirs — even on manual “Edit container resources” overrides. Anything above your tier ceiling is rejected with a clear message instead of silently truncated.

Per-team concurrent-deploy cap. If you push three branches at once on a plan that allows two simultaneous builds, the third one queues with a clear message instead of squeezing through and stretching the cluster.

The Usage page now shows the current calendar month's bandwidth, storage and build minutes — and never spills over to last month's numbers on the 1st of a new month. The dashboard “Build Mins” tile uses the same window, so the two views always agree.

Per-project Analytics now actually populates. Deploys, success rate, build minutes and last-build time all read from the right columns, so freshly deployed projects no longer show an empty page for hours.

Analytics has a real empty state. New projects with no deploys yet see a friendly “push to see your first build” message instead of a flat-line chart that looks broken.

The container-vitals notice on Analytics is now dismissible. Once you've read it, click “Dismiss” and it stays out of the way on every project for that browser.

Live build logs short-circuit instantly when a build is already finished and its log is saved. Re-opening a completed deploy renders the full log in one round-trip instead of streaming chunks back.

Usage syncing pulls in-flight deploy data from the engine in parallel with a per-request timeout, instead of waiting on each deploy in series. A team with many active builds sees the Usage page settle in a fraction of the time, and a slow engine response can no longer hang the page.

Real-time dashboard updates are now scoped to your active team and debounced, so cross-team activity no longer triggers needless re-fetches. The dashboard feels lighter on big workspaces.

Deleting a project now tells you the truth. If a piece of underlying infrastructure can't be cleaned up immediately, the dashboard reports a partial-success result with a follow-up action — instead of saying “Project deleted successfully” while quietly leaving resources behind.

Manual redeploys, force-rebuilds and rollbacks now record exactly which kind of trigger fired the build, so the deploy history reads correctly and the build-minute math is anchored to a real start time.

Build notifications no longer duplicate when the engine re-delivers the same terminal event. Each (build × outcome × teammate) is now guaranteed-once, so a re-tried delivery doesn't spam everyone's inbox.

Tightened access on notifications: only the owner can delete their own. Combined with our existing read/write policies, the rule set on this table is now end-to-end owner-scoped.

First-party visitor analytics. The new tracking endpoint accepts pings from your deployed sites only, is rate-limited per visitor IP, and silently drops requests for projects that don't exist — so it can't be probed for project IDs.

Lighter dashboard queries on large teams. Project lookups are capped and chunked, so the dashboard stays snappy even when a workspace has hundreds of projects across servers.

Deploy Hook tokens are now stored as one-way hashes. You see your secret exactly once at mint time, and we never read it back — so a leaked database snapshot can no longer be used to trigger your builds.

Build-status webhooks from LaunchVerse Engine are now replay-protected. Captured payloads can't be re-sent to falsely re-trigger your builds, and stale deliveries are rejected outright.

Account deletion is now atomic. Removing your account fully cleans up your profile and activity in one step instead of leaving stray records behind.

Stronger Content Security Policy across the dashboard. Every script tag now carries a per-request nonce, closing off a whole class of cross-site script-injection attacks.

The “Install LaunchVerse on GitHub” button always points at the right app for your environment — no more dead links when connecting a private repo.

Plan billing now follows the full subscription lifecycle. Failed renewals, cancellations and expired cards correctly revert teams back to Free at the right time — no more accidental free upgrades when a payment lapses.

Build-minute quotas are now actually enforced. Free teams get a clean stop at their monthly cap with a clear upgrade path, instead of metering past the limit.

GitHub auto-deploy connection status is visible in Project Settings. You can see whether your webhook is healthy, why it failed if not, and reconnect with one click — no more guessing why pushes aren't deploying.

Live build logs are dramatically faster when several teammates are watching at once. Multiple viewers now share a single stream, and polling automatically speeds up during active builds and eases off on idle ones.

Faster project lookups and tighter data integrity in our database. Cleaner indexes and stronger relationships mean fewer edge cases when servers are reassigned or deleted.

Manual deploys and GitHub auto-deploys now share the exact same connection path, so a project that works on one always works on the other.

Pin your Node version. The wizard auto-detects from your repo and lets you lock in Node 18, 20 or 22 — or stay on Auto-detect. Pinning shaves 3–5 seconds off every build by skipping runtime detection.

Pick your package manager. We auto-detect npm, yarn or pnpm from your lockfile and run the right install command. Switching to pnpm on lockfile-pinned projects is typically 30–50% faster.

Turbo build toggle for Next.js and Astro projects. Flip it on for the faster Turbo build pipeline; it's off by default and a no-op on frameworks that don't support it.

Faster installs, automatically. We now cache your installed dependencies between builds out of the box — a typical 90-second clean install drops to roughly 25 seconds on the next deploy. No setup required.

Persistent runtime cache for Next.js and friends. Opt in to keep your build-tool and image-optimisation caches across deploys, so incremental builds and ISR stay warm. Each project gets its own isolated cache, and turning the toggle off cleans everything up.

Everything you set in the deploy wizard is editable later from Project → Settings, and PR previews inherit the same options from their parent project.

The Node version and package manager dropdowns now show what we'd pick on Auto, so you can either trust the defaults or override with eyes open.

Cleaner project URLs. New projects deploy to a friendly subdomain based on your project name — for example, a project named “Solana” lands on `solana.hosted.launchverse.app`. If the name is taken we append a short 4-character suffix (`solana-7k2p.hosted.launchverse.app`) instead of a long random hash. You can still attach your own custom domain at any time.

Custom domains can now CNAME at our stable proxy hostname (`proxy.launchverse.app`) instead of pointing at a raw server IP. Set the CNAME once and it keeps working even if our underlying infrastructure moves — no “please update your DNS” emails from us. Apex domains continue to use an A record.

Private repositories now connect through our managed GitHub App. Tokens are minted fresh server-side for every deploy, so private-repo builds never silently break with a stale-credentials error after an hour. Existing projects keep working, with a one-step opt-in to the new connection.

Vite and similar SPAs no longer return 502 Bad Gateway after deploy. We now use each framework's actual default port (Vite, Astro, etc.) and patch existing projects on redeploy, so legacy projects pick up the fix automatically without a recreate.

Faster builds out of the box. We disable noisy install-time telemetry, audit pings and progress bars by default, knocking 5–30 seconds off most builds. Anything you set in your own environment variables still wins.

Faster repo clones. By default we now skip submodules and Git LFS on clone, on top of our existing shallow-clone behaviour, roughly halving clone time on monorepos that don't need either. Projects that do can re-enable both from Settings.

Your project's deploy URL now actually sticks on first deploy. We verify the URL was saved before declaring the build healthy and retry if it didn't, so the dashboard URL and the running site are always in agreement.

Build Minutes shown on the dashboard and on the Usage page now always match — and refresh instantly when you switch teams instead of waiting on a debounce.

New per-project Analytics tab. See deploys per day for the last 30 days, success vs. failure, success rate, total and average build minutes, and your configured CPU and memory ceilings — all on one page.

Private-repo deploys are more resilient. We now verify that your refreshed access token actually saved before kicking off a build, and retry alternative paths if it didn't — so private-repo builds work consistently across every infrastructure variant we run.

Your project's branded URL is guaranteed on every deploy. We always write your LaunchVerse URL onto your project ourselves instead of trusting whatever name the engine generated, so the URL you see in the dashboard is always the one that actually serves traffic.

Project preview thumbnails load ~40% faster, and we now show an instant shimmer skeleton while the image renders instead of a 5–10 second blank panel.

Deleting a project now cleanly stops it first. No more orphaned containers continuing to run after a delete on a busy host.

Custom-domain DNS instructions are smarter. We refuse to show private or container-only addresses as your “server IP” — falling back to your public platform IP or a clear support message — so you can never accidentally CNAME a public domain at an unreachable address.

CAPTCHA on login and signup is off. The extra friction wasn't worth it for the volume of bot traffic we were seeing.

Pushing twice in 30 seconds now only burns build-minutes on the latest commit. Older in-flight production builds are automatically cancelled and marked as Canceled in the dashboard before the new one starts.

If a webhook fires again for a commit we've already deployed, we don't rebuild — the deployment is logged as Skipped instead. The fastest build is the one that doesn't run.

Clicking Redeploy while a build is already in flight no longer queues a duplicate; you're pointed at the existing build instead. Force Rebuild and Rollback are still explicit overrides.

Instant feedback on Redeploy and Force Rebuild. The moment your click resolves you see a banner with a link to the live build log — no more 3-second blank wait.

Branded production URLs from day one. New projects deploy to a predictable LaunchVerse subdomain instead of a random engine-generated slug, so your URL is shareable from the very first deploy. Existing projects keep their current URL, with the branded one added alongside as a domain you can promote.

One deployment status across the entire dashboard. Project Overview, Projects list and the Deployment terminal all read the same source — the “Build: Ready / Runtime: Deploying” disagreement is gone, and the dashboard no longer gets stuck mid-deploy when an event is missed.

Private-repo deploys never go stale. We refresh your GitHub App token on every deploy, lifecycle action, rollback and promote — so containers never block on a “could not read username for github.com” error an hour after the last build.

Build logs are readable on first sight. We now unwrap structured engine output into clean stdout/stderr lines with timestamps and severity chips, instead of a raw JSON dump.

Build-minute billing now reflects actual build time, capped at 120 minutes per build. Time spent waiting in queue and orphaned/cancelled builds no longer count against your quota.

Faster builds out of the box. New projects come pre-configured with sane build defaults — caching on, shallow clone, sensible memory limits. You can override any of them under Project → Settings → Environment Variables, and your values always win.

Deploy Hook URLs are here. Every project now has a private POST endpoint you can call from any CI/CD pipeline (GitHub Actions, GitLab CI, your own scripts) to trigger a build on demand. Rotate or revoke the token from Project Settings, and copy a ready-to-paste GitHub Actions example straight from the panel.

The deploy wizard now defaults to forgiving installs. The most common first-time-deploy failure was a missing or out-of-date lockfile — we now use `npm install` by default and let you flip Strict back on once your lockfile is in shape.

Mobile polish: the deployment-logs page header wraps cleanly on narrow phones (Promote and Fullscreen no longer overflow), and the project overview shows a small “Syncing with engine…” line under the runtime pill while a build is in flight.

Private-repo builds re-mint your GitHub App access token on every redeploy. Pushing more than an hour after your first deploy no longer fails with a stale-credentials error.

Auto-deploys are reliable. Every GitHub push to a connected branch now triggers a production build, with the same fresh-token handling as PR previews.

PR preview environments are on by default for newly created projects. Every pull request gets its own ephemeral deployment, no extra setup required.

The project overview reconciles deployment state every 12 seconds during a build, so the “Deploying / Building” indicator never gets stuck — even if you close the build-log tab early.

The Usage & Quotas dashboard now shows the exact limits we enforce on every plan — projects, databases, build minutes, per-project CPU/memory ceilings and concurrent previews, all in one place.

Build-log viewer is mobile-friendly. On narrow screens, the timestamp and severity chip stack above the message instead of stealing horizontal space.

New Guides hub at /guides with 5 long-form articles, including how LaunchVerse stacks up against Vercel, Netlify and the wider African cloud landscape.

New FAQ page at /faq covering Naira billing, Bring Your Own Server, supported frameworks and refunds — with rich-result markup so it shows up properly on Google.

Guides are now authored in Markdown so we can ship new posts in minutes, not hours.

Sitemap and robots.txt always emit fully-qualified URLs and auto-discover new guides as we publish them.

Account deletion now fully wipes your profile data instead of leaving stray records behind.

Your GitHub access tokens are encrypted at rest with AES-256-GCM. Even a worst-case data leak doesn't expose them.

Team invitations can no longer grant the Owner role. Promotion to Owner now requires an explicit, separately authorised step.

Sensitive actions — rollback, top-level domains, account deletion — now require Owner or Developer role before they can change anything.

Rate limits on lifecycle, environment variables, custom domains and account-deletion actions, to keep both you and the platform safe from runaway scripts and abuse.

Per-environment environment variables. Staging, production and your custom environments can now each carry their own values for the same key.

Web Shell tab on every project. Owners and Developers can drop into a live shell on the running container for quick debugging — no SSH setup required.

PR previews tear themselves down when the pull request closes, with a per-team cap to keep things tidy. Find them all under Project → Previews.

Editing multiple environment variables in a row now triggers a single redeploy after you finish, instead of one rebuild per variable.

Dashboard pages respect your currently active team across the board — the first team you joined no longer wins by default.

Plan upgrades route correctly even when two plans share the same Naira price. We dispatch on intent, not price tag.

API errors now return a consistent shape across every route — useful if you're scripting against our public endpoints.

Each team can now have only one active subscription. We cleaned up legacy duplicates and added a database-level guard so they can't recur.

Public marketing and legal pages now publish a proper sitemap.xml and robots.txt for search engines. Authenticated dashboard, project and API surfaces stay disallowed.

The sitemap always emits absolute https:// URLs, so Google Search Console accepts it cleanly.