How to Deploy Static Sites on Vercel Without a Build Step

November 19, 2026 13 min read By Bejoy Naduvilathara Joy
How to Deploy Static Sites on Vercel Without a Build Step

Publishing a small website usually involves more steps than the project itself requires. You prepare the HTML, CSS and images, run a deployment command, wait for the build environment to start, and then wait for the deployment to finish.

For a simple static page, much of that process can be unnecessary.

Vercel’s expanded instant deployment support changes this workflow. Eligible static projects can now be deployed with their assets directly, without running a conventional build step. Vercel says these deployments can be ready in approximately one second.

The update makes this approach more useful than before. It now supports stylesheets, images, fonts, JSON files, documents and media alongside HTML and Markdown.

For indie developers, landing-page creators and people publishing small static projects, this offers a quicker way to put finished files online.

The important part is understanding what qualifies. Instant deployment has strict file-count and size limits, and projects containing JavaScript or certain configuration files can fall back to the normal build process.

Quick Summary

  • Vercel instant deployments let eligible static websites go live without a conventional build step.
  • Deploy a folder using vercel deploy ./my-static-site.
  • Supported assets include CSS, JSON, XML, images, fonts, PDFs, audio and video.
  • Each instant deployment supports up to 100 files and 25 MB in total.
  • Vercel automatically detects eligible projects; no special configuration is required.
  • JavaScript files, framework presets, custom build settings, a root-level package.json, vercel.json or a public/ directory can trigger the normal build process.
  • Git-triggered deployments continue through the conventional build workflow.

What Are Vercel Instant Deployments?

Vercel instant deployments are a way to publish eligible static files without asking Vercel to run a build process first.

In a conventional deployment, Vercel may need to install dependencies, execute a build command, process application files and prepare the resulting output. That is necessary for frameworks and applications that require compilation.

A finished static website is different. If its HTML already references the correct CSS, images and other assets, there may be nothing to compile.

Instant deployment takes advantage of that distinction. Vercel receives the ready-to-serve files and publishes them directly.

The expanded support makes this more practical for complete static pages. Previously, the fast deployment path was limited to HTML and Markdown. It now accepts several additional asset categories, allowing developers to publish more than a single standalone document.

This is particularly useful when a project is already generated and does not need a framework or bundler to prepare it.

Which File Types Does Vercel Support?

The expanded instant deployment path supports several categories of static assets.

CategorySupported file types
Web pagesHTML, HTM and Markdown
Styles and dataCSS, JSON, XML, plain text and web manifests
ImagesSVG, PNG, JPEG, GIF, WebP, AVIF and ICO
FontsWOFF, WOFF2, TTF, OTF and EOT
DocumentsPDF
VideoMP4 and WebM
AudioMP3, WAV and OGG

These formats cover many small web projects. A landing page can include its stylesheet, logo, illustrations, custom fonts and supporting documents without requiring a separate build step.

However, supported file extensions alone do not guarantee an instant deployment. The project must also satisfy the deployment limits and avoid the conditions that trigger a conventional build.

Vercel Instant Deployment Limits

There are two important limits to remember:

LimitMaximum
Number of files100
Combined deployment size25 MB

Both conditions must be satisfied.

For example, a static landing page containing 18 files with a combined size of 8 MB fits within these limits. A project containing 105 small files does not qualify, even if its total size is only 5 MB.

The same applies to a project with 30 files that collectively exceed 25 MB.

These limits apply to the instant deployment path. They should not be confused with Vercel’s broader CLI upload limits for conventional deployments.

Before deploying, check the number and total size of the files in your project. This simple check can help explain why an otherwise static folder might not qualify for the fast path.

How to Deploy a Static Website in Approximately One Second

You do not need a framework, bundler or custom build script for a basic static website.

For this example, create a small project containing an HTML page, a stylesheet and an image.

Step 1: Prepare Your Static Website

Create a project folder named my-static-site.

Organize the files like this:

my-static-site/
├── index.html
├── styles.css
└── assets/
    ├── logo.svg
    └── hero.webp

This example contains four files. It stays within the instant deployment limits and uses supported file types.

Make sure the HTML references the assets using paths that match the folder structure.

For example:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>My Static Website</title>
  <link rel="stylesheet" href="/styles.css">
</head>
<body>
  <main>
    <img src="/assets/logo.svg" alt="Website logo">
    <h1>My website is live</h1>
    <p>A simple static page deployed directly to Vercel.</p>
    <img src="/assets/hero.webp" alt="Website hero artwork">
  </main>
</body>
</html>

Add your styles to styles.css:

* {
  box-sizing: border-box;
}

body {
  margin: 0;
  min-height: 100vh;
  display: grid;
  place-items: center;
  padding: 32px;
  background: #f8fafc;
  color: #172033;
  font-family: Arial, sans-serif;
}

main {
  width: min(100%, 720px);
  text-align: center;
}

main > img:first-child {
  width: 64px;
}

main > img:last-child {
  width: 100%;
  border-radius: 16px;
}

h1 {
  margin-bottom: 12px;
  font-size: 42px;
}

The example deliberately uses HTML and CSS without JavaScript. It is already prepared for the browser, so there is no client-side compilation step to perform.

Step 2: Install Vercel CLI

If you have not installed the Vercel CLI, install it with npm:

npm install -g vercel

Check that the command is available:

vercel --version

You will also need to authenticate with your Vercel account before deploying.

Run:

vercel login

Follow the authentication instructions in your terminal.

Step 3: Deploy the Folder

Move to the directory containing your project, or provide the folder path directly.

Run:

vercel deploy ./my-static-site

Vercel automatically checks whether the submitted files qualify for instant deployment.

If the project meets the requirements, Vercel can publish the files without running a conventional build step.

The expected result is a deployment confirmation with a unique preview URL. Vercel’s announcement demonstrates an eligible deployment becoming ready in approximately one second.

The actual time can vary. Treat one second as Vercel’s reported result for eligible deployments, not a guaranteed completion time for every project.

Step 4: Open and Test the Preview URL

After deployment, the CLI provides a URL for the new deployment.

Open it in your browser and check:

  • The homepage loads correctly.
  • Stylesheets are applied.
  • Images and fonts load from their expected paths.
  • Internal links point to valid pages.
  • Documents and media files are accessible.
  • The layout works on mobile and desktop screens.

A successful upload does not replace browser testing. Incorrect asset paths, missing files and HTML errors can still affect the published website.

The generated URL is useful for reviewing a page before sharing it with others.

Preview Deployment or Production Deployment?

A deployment URL should not automatically be treated as your permanent production address.

Vercel provides different deployment environments, including Preview and Production. The CLI supports deployment targets, and the standard deployment workflow can be used to publish to production.

For an initial review, use a preview deployment. Once the page is ready, follow the appropriate production deployment workflow for your Vercel project.

For example, the conventional CLI production command is:

vercel --prod

Do not assume that every instant deployment command automatically assigns your production domain. Check the deployment target and project configuration before publishing changes to a live site.

When Does Vercel Use the Normal Build Process?

This is the most important limitation to understand.

Vercel does not skip the build process for every project. If a deployment does not meet the instant deployment conditions, it continues through the conventional build workflow.

The following conditions can trigger that behaviour.

1. JavaScript Files

A project containing JavaScript files does not qualify for the expanded instant deployment path described in the announcement.

For example:

my-static-site/
├── index.html
├── styles.css
└── app.js

Even if app.js is a small file that runs directly in the browser, its presence means the deployment falls outside the stated instant deployment eligibility.

This distinction matters because browser-ready JavaScript and build-time JavaScript are not the same thing. However, Vercel’s published eligibility rules identify JavaScript files as a reason for using the normal build process.

If your project needs JavaScript, use the conventional deployment workflow rather than assuming the instant path will accept it.

2. Framework Presets

Projects configured with a framework preset use the normal build process.

Frameworks such as Next.js and other application frameworks often need a build stage to generate the files Vercel serves.

Instant deployment is intended for ready-to-serve static assets, not for replacing framework compilation.

3. Custom Build Settings

Custom build settings can also prevent a project from qualifying.

If your Vercel project has a configured build command or other custom build settings, Vercel uses the normal build workflow.

This is an important consideration when reusing an existing project. A folder containing only HTML and CSS might appear eligible, but its project configuration can change how Vercel processes the deployment.

4. A Root-Level package.json

A package.json file at the root of the project is another condition that triggers the normal build process.

For example:

my-static-site/
├── package.json
├── index.html
└── styles.css

A package manifest is commonly used to define dependencies, scripts and project metadata. Its presence can indicate that the project belongs to a JavaScript development workflow.

If you are publishing a standalone static page, avoid adding project files that are not needed.

Do not remove a package.json from an application simply to force instant deployment. If the project genuinely depends on packages or build scripts, keep its normal build process.

5. A Vercel Configuration File

A root-level Vercel configuration file, such as vercel.json, also prevents the project from using this instant deployment path.

Configuration files can define routing, redirects, headers and other deployment behaviour. Those settings may require the conventional processing workflow.

If your project depends on custom Vercel configuration, use the normal deployment process.

6. A public/ Directory

A root-level directory named public/ is also listed among the conditions that trigger the normal build process.

This is worth checking when moving an existing framework project into a standalone static deployment.

A simple static folder can use its own asset directories, such as assets/ or images/, but do not rename or restructure an existing application without checking how its file paths and build process work.

7. Git-Triggered Deployments

The expanded instant deployment path applies to deployments made through the Vercel CLI or REST API.

Deployments triggered through Git continue to use the normal build process.

That means pushing a commit to a connected repository does not automatically switch the project to instant deployment.

If your workflow depends on Git-based continuous deployment, keep using the existing pipeline.

Instant Deployment vs Conventional Vercel Deployment

Both approaches publish projects to Vercel, but they solve different problems.

FeatureInstant deploymentConventional deployment
Main purposeReady-to-serve static filesApplications and build-dependent projects
Build stepSkipped for eligible projectsRuns when required
Deployment methodsCLI or REST APIGit, CLI and REST API
File eligibilityRestricted supported static filesSupports build-based project workflows
File limit for this path100 filesSubject to broader platform limits
Size limit for this path25 MBSubject to broader platform limits
Framework compilationNot supported by the instant pathSupported
Best useSmall static websites and reportsFramework applications and complex projects

The key difference is not simply speed. It is whether the project needs to be transformed before it can be served.

A static HTML page can be published directly. A React application that needs bundling, dependency installation or framework processing still needs its build pipeline.

When Should Developers Use Vercel Instant Deployments?

The feature is most useful when the project is already prepared and does not require a compilation stage.

Small landing pages

A campaign page containing HTML, CSS, images and fonts can be published quickly without setting up a full frontend build workflow.

Static reports

Developers and automated tools can generate HTML reports and publish them for review. PDF documents and other supported assets can be included within the deployment limits.

Design and UI prototypes

A simple HTML/CSS prototype can be shared through a live URL. This is useful when a designer or developer wants feedback without preparing a full application.

Generated static websites

An automated workflow can produce a small set of ready-to-serve files and send them directly to Vercel through the CLI or API.

Small documentation pages

A limited collection of static documentation files can be published without introducing a framework solely for deployment.

The common requirement is that the files must already be ready to serve and remain within the eligibility rules.

Can You Use the Vercel REST API?

Yes. Vercel’s announcement identifies both the CLI and REST API as deployment methods for instant static deployments.

The CLI is the simpler starting point for an individual developer. It requires less setup and makes it easy to publish a local folder.

The REST API is more useful when deployment is part of an automated system.

For example, a service could generate a static report, collect the resulting HTML and assets, and submit them to Vercel programmatically. This can be useful for internal tools, content-generation workflows and applications that create shareable pages.

However, API deployments require more preparation. You need to authenticate with an access token and follow Vercel’s deployment file-upload and deployment-creation process.

The general API workflow involves:

  1. Preparing the files for deployment.
  2. Calculating file hashes.
  3. Uploading the files to Vercel.
  4. Creating a deployment using the uploaded file references.
  5. Retrieving the deployment status and URL.

The API is therefore better suited to developers building automation around deployment rather than someone publishing a folder manually for the first time.

Common Reasons an Instant Deployment Does Not Happen

If Vercel runs a conventional build instead of publishing your files directly, check the project before changing anything.

What to checkWhy it matters
More than 100 filesExceeds the instant deployment file limit
More than 25 MB totalExceeds the instant deployment size limit
JavaScript or unsupported filesMakes the project ineligible
Framework presetTriggers the normal build workflow
Custom build settingsPrevents instant deployment
Root-level package.jsonTriggers the normal build workflow
vercel.jsonTriggers the normal build workflow
Root-level public/ directoryTriggers the normal build workflow
Git-triggered deploymentUses the conventional build process

Start by checking the file structure and project settings. If the project needs any of these features, a normal build is not a failure. It is the correct deployment method for that project.

Final Thoughts

Vercel instant deployments make publishing small static projects simpler by removing a build step that some websites do not need.

The expanded file support is the meaningful part of the update. Developers can now deploy a complete small page with stylesheets, images, fonts and other static assets instead of being limited to a basic HTML or Markdown document.

The workflow is straightforward: prepare the files, authenticate with the CLI and run vercel deploy ./my-static-site.

But the feature has a clear boundary. It is designed for small, ready-to-serve static projects—not framework applications, JavaScript-based deployments or projects that depend on custom build configuration.

For the right kind of project, skipping the build can make publishing feel almost immediate. For everything else, Vercel’s conventional deployment workflow remains the appropriate choice.

Stay tuned to Pixoptimo as we bring you the latest insights on design, development, tools, and the technology shaping the web.