Deploy a Next.js App with Server Components.

You just built a Next.js app with Server Components — and it works. Then comes the question every developer asks next: how do I put it in production?

You hear about Docker, servers, environment variables, network configuration — and it's easy to think you need to manage all of that yourself. You don't. With Qeda Cloud, the workflow is much more direct: connect your Git project, Qeda detects your Next.js application, then you launch the deployment. At the end, your application is accessible through an HTTPS URL.

In this guide, we will deploy a Next.js application using Server Components.

What are Server Components?

If you use the Next.js App Router, your components are Server Components by default — some parts of your interface can run on the server instead of in the browser. For example, you can have a page that fetches data:

export default async function ProductsPage() {
  const response = await fetch("https://example.com/api/products");
  const products = await response.json();

  return (
    <main>
      <h1>Products</h1>

      {products.map((product) => (
        <p key={product.id}>{product.name}</p>
      ))}
    </main>
  );
}

For this article, you do not need to master every detail of how Server Components work. The important idea is simply: Next.js can run part of your application on the server, and Qeda can host that application.

Prepare your Next.js project

You need a working Next.js project — something like:

my-next-app/
├── app/
├── public/
├── package.json
└── ...

If your application already works locally with npm run dev, you are ready. You do not need to create a Dockerfile or manually prepare a server for Qeda.

Put your project on Git

If your project is already on GitHub, you can move directly to the next step — otherwise, simply put your project in a Git repository so Qeda can retrieve your code. That is all you need to get started.

Connect your project to Qeda

From your Qeda Dashboard, create a new application, then connect your Git repository. Pick it from the repository picker — with an account switcher if you have both personal and organization GitHub installations — and Qeda scans your project and detects your Next.js application automatically. The build command, start command and port are pre-filled for you, tucked under Advanced settings if you ever need to adjust them.

You do not need to configure Node.js yourself or prepare an entire server infrastructure — Qeda Builder handles the preparation of your application. You select your project, then launch the deployment.

Click Deploy

This is now the simplest part: from your Dashboard, click Deploy. Qeda retrieves your project, prepares your Next.js application, and launches the deployment. During this time, you can follow the deployment status from your Dashboard — live build logs stream in as they happen, and the status badge on your service moves from Building to Running.

Your Next.js application is online

Once the deployment is complete, Qeda gives you an HTTPS URL — for example, https://my-next-app.qeda.app. Open this address in your browser and you should see your Next.js application, just like when you tested it locally. The only difference: it is now accessible on the Internet.

Test your Server Components

Now is the time to check that your application works correctly in production. If you have a page using a Server Component to fetch data, simply open that page in your browser. You can also test your URL directly:

$ curl https://my-next-app.qeda.app

If your page displays correctly, your Next.js application is accessible. You can then test the important features of your application:

• navigation between pages
• data fetching
• dynamic content display
• forms
• authentication, if your project uses it

No need to run a complicated test suite to get started — just open your application and check that the main features work.

Does your application use environment variables?

This is common in a Next.js application — you may need variables for a database, an external API, an authentication service, an API key, or a payment service, something like:

DATABASE_URL=...
API_KEY=...

In that case, configure your environment variables from your Qeda environment instead of putting them directly in your code. From your service's Settings tab, add each variable directly — Qeda injects them at build and runtime. This is especially important for sensitive information.

Your code can then remain in Git without exposing your keys.

Does your Next.js app use a database?

Your application may also need PostgreSQL — for example, your Server Components might fetch products, users, or orders from a database. Qeda provides PostgreSQL as a ready-to-use service: add it to your project in one click from the Marketplace. You do not need to administer a separate PostgreSQL server yourself.

Do you want to use your own domain?

The qeda.app URL is convenient to get started, but if you already own a domain, you can connect your own address to your application — something like https://myproject.com or https://app.myproject.com. Qeda also supports HTTPS for your domain, so you keep your own address without having to manage certificates yourself.

What happens when you modify your application?

This is where the Git-to-Deploy workflow becomes especially useful: you modify your Next.js application, push your changes to Git, and Qeda deploys the new version — you do not need to manually rebuild your entire infrastructure after every change. You simply keep developing your application.

Quick check

Before considering your deployment complete, simply check that:

• your application responds — curl https://my-next-app.qeda.app
• your main page opens correctly in the browser at https://my-next-app.qeda.app
• a page using Server Components fetches and displays its data correctly
• your environment variables are configured, if your application uses an API, a database, or another external service

Conclusion

Deploying a Next.js application with Server Components does not need to become a DevOps project. With Qeda, you connect your Git repository, launch the deployment, and quickly get an HTTPS URL — then add a PostgreSQL database, configure your environment variables, or connect your own domain whenever you need to.