---
title: How to Deploy a Solid App with Vercel
description: Deploy Solid to Vercel with zero configuration. Covers SolidStart 1 and 2, static Solid apps, build settings, and custom domains.
url: /kb/guide/deploying-solid-with-vercel
canonical_url: "https://vercel.com/kb/guide/deploying-solid-with-vercel"
published: 2025-11-03
last_updated: 2026-08-18
authors: Vercel
related: []
install_vercel_plugin: npx plugins add vercel/vercel-plugin
---
<!-- docsgraph:related -->
## Related pages

> **For AI agents:** Follow these links to understand how this page connects to the rest of the Vercel ecosystem. For the full cross-link map (inbound, outbound, prerequisites, and semantic neighbors), see the .graph.md link below.

- [Supported Frameworks on Vercel](https://vercel.com/docs/frameworks/more-frameworks?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Learn about the frameworks that can be deployed to Vercel.
- [Vite on Vercel](https://vercel.com/docs/frameworks/frontend/vite?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Deploy Vite projects to Vercel and configure environment variables, Vercel Functions, server-side rendering, and SPA rew
- [Nitro on Vercel](https://vercel.com/docs/frameworks/backend/nitro?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Deploy Nitro applications to Vercel with zero configuration. Learn about observability, ISR, and custom build configurat
- [Announcing the Build Output API](https://vercel.com/blog/build-output-api?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related)
- [Frontends on Vercel](https://vercel.com/docs/frameworks/frontend?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Vercel supports a wide range of the most popular frontend frameworks, optimizing how your application builds and runs no
- [Deploy a TanStack Start app to Vercel](https://vercel.com/kb/guide/deploy-a-tanstack-start-app-to-vercel?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Learn how to deploy a TanStack Start app to Vercel using the Nitro Vite plugin. Covers framework setup, Git and CLI depl
- [Migrate a TanStack Start app from Netlify to Vercel](https://vercel.com/kb/guide/migrate-a-tanstack-start-app-from-netlify-to-vercel?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Move your TanStack Start app off Netlify and onto Vercel Functions, where Fluid compute scales it automatically. Swap to
- [What is the Nitro Vite plugin?](https://vercel.com/kb/guide/nitro-vite-plugin?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — The Nitro Vite plugin \\(nitro/vite\\) adds SSR, API routes, and deploy-anywhere server builds to any Vite app. Learn what
- [How to ship a Nitro app on Vercel](https://vercel.com/kb/guide/ship-a-nitro-app-on-vercel?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Deploy a Nitro app to Vercel with zero configuration. Learn how to ship from a template, the Vercel CLI, or Git, and con
- [How to Deploy a Polymer App with Vercel](https://vercel.com/kb/guide/deploying-polymer-with-vercel?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=related) — Create a Polymer app and deploy it live with Vercel.

Full cross-link map for this page: [/kb/guide/deploying-solid-with-vercel.graph.md](/kb/guide/deploying-solid-with-vercel.graph.md?from=related&source_path=%2Fkb%2Fguide%2Fdeploying-solid-with-vercel&source_site=vercel-kb&relationship=graph)
<!-- /docsgraph:related -->


Vercel detects Solid projects during import and applies the build settings for you, so most Solid apps deploy without a configuration file. What you need to know depends on whether you run Solid on its own as a client-rendered app or through SolidStart, which adds server rendering, API routes, and a production server build.

This guide covers both paths, the build settings for each, and the differences between SolidStart 1 and SolidStart 2. We'll also cover deploying Polymer, Aurelia, Charge, Hexo, and Middleman to Vercel.

## What you need to deploy Solid to Vercel

You should start by confirming three things about your project and account:

- **A Solid or SolidStart project:** Run `npm init solid` to scaffold one with `create-solid`, the official Solid scaffolding tool. Its prompts ask whether you want a SolidStart project, so the same command covers both paths.
  
- **A Git repository or Vercel CLI:** Vercel imports from GitHub, GitLab, and Bitbucket, or deploys from your machine with the `vercel` command.
  
- **Node.js 24 for SolidStart 2:** SolidStart 2 requires Node.js 24 or newer. Vercel's default for new projects is already 24.x, so you rarely need to change it.
  

With those in place, it helps to know what Vercel does with your project at build time before you pick a path.

## How Vercel detects and builds a Solid app

Vercel inspects your `package.json` on import and matches it against a list of framework presets. Each preset includes a default build command, output directory, and development command, which is why a Solid project deploys without a configuration file.

### Framework presets for Solid and SolidStart

Detection depends on which packages your project depends on. The SolidStart preset matches when both `solid-js` and `@solidjs/start` are present, while a Solid project without SolidStart matches the Vite preset through its `vite` dependency.

The following table shows what each project type maps to:

| Project type             | Framework preset | Build command                        | Output directory                        |
| ------------------------ | ---------------- | ------------------------------------ | --------------------------------------- |
| SolidStart 2             | SolidStart (v1)  | `vite build`, from your build script | Produced by the Nitro deployment plugin |
| SolidStart 1             | SolidStart (v1)  | `vinxi build`                        | `.output`                               |
| SolidStart 0.x           | SolidStart (v0)  | `solid-start build`                  | `.output`                               |
| Solid without SolidStart | Vite             | `vite build`                         | `dist`                                  |

Vercel's preset list names SolidStart 1 and SolidStart 0.x, and a SolidStart 2 project still matches the SolidStart (v1) preset because it depends on the same two packages. That works because the build command does not come from the preset when your project defines one.

Vercel checks for a build script in `package.json` and runs that first, falling back to the preset default only when no script exists.

### Static Solid apps compared with SolidStart server rendering

The choice between the two paths determines how Vercel serves your app. A Solid app built with Vite alone compiles to static HTML, CSS, and JavaScript that Vercel serves from its CDN, with routing handled in the browser.

SolidStart changes that by producing a server build alongside your client assets. Its server routes and rendered pages become Vercel Functions running on Fluid compute, which is what lets you use server-side rendering, API routes, and middleware.

Start with the SolidStart path below if your app needs any of those.

## How to deploy a Solid or SolidStart app to Vercel

Every Solid project follows the same sequence on Vercel. Configure the project for what you are running, then deploy, add a domain, and wire up continuous deployment. Only the configuration step differs between a static Solid app and a SolidStart app.

SolidStart reaches Vercel through Nitro, the server toolkit that turns your server build into a deployable output. How you wire Nitro is the one thing that changed between SolidStart 1 and SolidStart 2, so configure your version first, then deploy.

Here's the process.

### Configure your project for what you are running

Only one of the three options below applies to your project, so pick the one that matches your setup and skip the other two.

#### Configure SolidStart 2 with the Nitro deployment plugin

SolidStart 2 builds on Solid 1 and Vite 8 or newer, using Vite's Environment API for both client and server builds. Configuration lives in `vite.config.ts`, where the `solidStart()` plugin sets up the application and a separate deployment plugin connects the server build to a hosting target.

Install the Nitro package to get that deployment plugin:

```bash
npm i nitro
```

Nitro provides portable deployment presets, including one for Vercel.

Then, add `nitro()` after `solidStart()` in your Vite configuration:

```typescript
import { nitro } from "nitro/vite";
import { defineConfig } from "vite";
import { solidStart } from "@solidjs/start/config";

export default defineConfig({
  plugins: [solidStart(), nitro()],
});
```

No Vercel-specific option is needed here. Nitro's Vercel integration works with zero configuration: Nitro detects the platform during the build and produces output that Vercel deploys as-is.

If you need to reach other Nitro options such as prerendering, scheduled tasks, or Incremental Static Regeneration, set them on the top-level `nitro` property in the same Vite configuration.

#### Configure SolidStart 1 with the Vercel preset

SolidStart 1 runs Nitro through Vinxi rather than a Vite plugin, and it exposes Nitro's presets through a `server` option in `app.config.ts`. Nitro can detect Vercel on its own here, and Vercel's own SolidStart example sets the preset explicitly.

Set the `vercel` preset in your app configuration:

```typescript
import { defineConfig } from "@solidjs/start/config";

export default defineConfig({
  server: {
    preset: "vercel"
  }
});
```

SolidStart relies on async local storage, which Vercel supports without extra configuration. If you are planning to move to SolidStart 2, the framework publishes a migration guide for the change from Vinxi to Vite plugins.

#### Configure a static Solid app with the Vite preset

A Solid app without SolidStart needs no server build, so this path is shorter. Vercel matches it to the Vite preset, runs `vite build`, and serves the contents of `dist` as static assets.

Nothing needs configuring here. Confirm that the Framework Preset shows Vite when you import the project, and the defaults handle the rest.

If you later want server rendering or API routes without moving to SolidStart, you can add Nitro to an existing Vite project using the Vite and Nitro integration.

To expose Vercel's system environment variables to a Solid app at build time, prefix the variable name with `VITE_`. Both the Vite and SolidStart presets set that prefix, so `VITE_VERCEL_ENV` resolves to `production`, `preview`, or `development` depending on the deployment.

### 1\. Deploy your Solid app from Git or Vercel CLI

Once your configuration matches what you are running, either import path works without further setup.

To deploy from a Git repository, follow these steps:

1. Push your Solid project to GitHub, GitLab, or Bitbucket.
   
2. Import the repository at vercel.com/new.
   
3. Confirm that Vercel selected the expected preset, SolidStart or Vite, and that the build command matches your build script.
   
4. Select Deploy.
   

To deploy from your machine instead, install Vercel CLI and run `vercel` in your project directory. The CLI detects the framework and applies the same settings as the dashboard, which keeps local deployments consistent with what Git imports produce.

### 2\. Add a custom domain to your Solid app

Every deployment gets a `.vercel.app` domain automatically, which is enough for previews but rarely what you want in production.

Add a custom domain from your project's Settings, using a domain you already own or one registered through Vercel. Vercel provisions the certificate for you, so the domain serves over HTTPS once the DNS records resolve.

### 3\. Set up continuous deployment for Solid on Vercel

Connecting a Git repository does more than seed the first deployment. Vercel's Git integrations for GitHub, GitLab, and Bitbucket build every push, so production tracks your default branch and each pull request gets its own preview deployment at a shareable URL.

You can also run checks against those preview URLs before a merge, which catch performance and reliability regressions in the deployed app rather than in a local build.

## How to troubleshoot a Solid deployment on Vercel

Most failed Solid deployments trace back to a mismatch between the framework version and the build settings.

Work through these causes in order:

- **A build command pinned to Vinxi:** SolidStart 2 does not use Vinxi. If your project settings override the build command to `vinxi build`, or your build script still calls it, the build fails once you upgrade. Set the script to `vite build` and clear the override.
  
- **A missing deployment plugin:** A SolidStart 2 build without `nitro()` in `vite.config.ts` produces no deployable server output. Add the plugin and redeploy.
  
- **A Node.js version below 24:** SolidStart 2 requires Node.js 24 or newer. Confirm the version under **Settings** > **Build and Deployment** > **Node.js Version**, or pin it in `package.json`.
  
- **An output directory override:** The SolidStart preset defaults to `.output`, which matches SolidStart 1. Leave the output directory unset for SolidStart 2 so the Nitro plugin controls it.
  
- **The wrong preset on a static app:** A Solid app without SolidStart should use the Vite preset and output to `dist`. Selecting a SolidStart preset points Vercel at a directory the build never creates.
  

To pin the Node.js version alongside your code, add an `engines` field:

```json
{
  "engines": {
    "node": "24.x"
  }
}
```

A value in `package.json` overrides the version selected in project settings, keeping the runtime consistent across all environments.

## Deploying Polymer, Aurelia, Charge, Hexo, or Middleman to Vercel

Polymer, Aurelia, Charge, Hexo, and Middleman still deploy to Vercel, though three are worth a status check before you start a new project with one.

The following table summarizes where each one stands as of this writing (August 2026):

| Framework | Status                                                       | Vercel framework preset | Build command                 | Output directory |
| --------- | ------------------------------------------------------------ | ----------------------- | ----------------------------- | ---------------- |
| Hexo      | Actively maintained, 8.1.2 released May 2026                 | Hexo                    | `hexo generate`               | `public`         |
| Middleman | Actively maintained, gem 4.6.3 released February 2026        | Middleman               | `bundle exec middleman build` | `build`          |
| Polymer   | Maintenance only, 3.5.2 released October 2024                | Polymer                 | `polymer build`               | `build`          |
| Aurelia   | Aurelia 1 dormant since 2023, Aurelia 2 at release candidate | None                    | Set manually                  | Set manually     |
| Charge    | Dormant, 1.7.0 released March 2020                           | None                    | Set manually                  | Set manually     |

The three with presets need no configuration. Import the repository and Vercel applies the build command and output directory shown above.

Here are things you should know per framework:

- **Hexo:** The Node.js blog framework remains under active development and keeps a Vercel preset, so a Hexo blog deploys with zero configuration.
  
- **Middleman:** The Ruby static site generator is also actively maintained and keeps its preset. Vercel runs `bundle exec middleman build`, so commit your `Gemfile` and `Gemfile.lock`.
  
- **Polymer:** Google's original Web Components library is in maintenance rather than active development. The Polymer team recommends Lit for new projects, and because both compile to standard Web Components, you can migrate one element at a time. Existing Polymer apps still deploy through the Polymer preset.
  
- **Aurelia:** Aurelia 1 has seen no repository activity since January 2023, while Aurelia 2 is under active development and ships as a release candidate rather than a final release. Aurelia no longer appears in Vercel's framework preset list.
  
- **Charge:** The static site generator was last released in March 2020 and no longer appears in Vercel's preset list. Treat it as unmaintained for new work.
  

For Aurelia, Charge, or any framework without a preset, set Framework Preset to Other and fill in the build command and output directory your tooling produces. Vercel's guide to configuring a build covers those fields and how to override them per deployment.

## Next steps

With your framework build settings confirmed, the remaining work is importing the project.

Import your repository at vercel.com/new to deploy it, or start from a preconfigured project in the template gallery.

## Related resources

- Frameworks on Vercel
  
- Supported frameworks on Vercel
  
- Nitro on Vercel
  
- Configuring a build
  
- Supported Node.js versions
  
- SolidStart deployment plugins
  
- Deploying Solid to Vercel, from the Solid docs
  

## Frequently asked questions

### Does Vercel support SolidStart?

Yes. Vercel ships a SolidStart framework preset that activates when your project depends on `solid-js` and `@solidjs/start`, setting the build command and output directory for you. SolidStart server routes deploy as Vercel Functions on Fluid compute, giving you server rendering and API routes without configuration files.

### Do I need an adapter to deploy SolidStart to Vercel?

No separate Vercel adapter package exists. SolidStart 2 uses the Nitro deployment plugin, added as `nitro()` in `vite.config.ts`, and Nitro detects Vercel automatically. SolidStart 1 instead sets `server.preset` to `vercel` in `app.config.ts`. Both routes rely on Nitro rather than a Vercel-specific adapter.

### Can I deploy a Solid app to Vercel without SolidStart?

Yes. A Solid app built with Vite alone deploys as a static site. Vercel matches it to the Vite preset, runs `vite build`, and serves `dist` from the CDN. You give up server rendering and API routes, so choose this path for client-rendered apps that need no server.

### Why does my SolidStart build fail on Vercel after upgrading to version 2?

SolidStart 2 replaced Vinxi with Vite plugins, so a build command still calling `vinxi build` fails. Set your build script to `vite build`, clear any build command override in project settings, add `nitro()` to `vite.config.ts`, and confirm the project runs Node.js 24 or newer.

### Is Polymer still maintained, and what should I use instead?

Polymer is in maintenance rather than active development, with its last release in October 2024. The Polymer team recommends Lit for new projects. Both compile to standard Web Components, so Polymer and Lit elements interoperate, and you can migrate incrementally. Existing Polymer apps still deploy to Vercel through the Polymer preset.