# Welcome! Let's get up and running on Render.

**This tutorial uses free Render resources. No payment is required.** All you need is a repository connected to a supported Git provider with the web app you want to deploy.

**Want to deploy an example app using a particular language or framework?**
Check out our [quickstarts](/content/docs#quickstarts/index.html).

## 1. Sign up

Signing up is fast and free:

[Sign up for Render](https://dashboard.render.com/register)

## 2. Connect your Git provider

You can deploy to Render from a supported Git provider.

1. Open your [Account Settings](https://dashboard.render.com/u/settings#account-security) page and scroll down to the **Account Security** section:

2. Under **Git Deployment Credentials**, click **Add credential** and authorize Render with your provider.

## 3. Choose a service type

To deploy on Render, you create a **service** that pulls, builds, and runs your code.

For this tutorial, you'll create a **Web Service** or a **Static Site**:

| Service type | Description | Common frameworks |
| --- | --- | --- |
| **Web Service** | Choose this if your web app runs any server-side code. The app also needs to listen for HTTP requests on a port.<br>Full-stack web apps, API servers, and mobile backends are all web services. | Express, Next.js, Fastify, Django, FastAPI, Flask, Rails, Phoenix |
| **Static Site** | Choose this if your web app consists entirely of static content (mostly HTML/CSS/JS).<br>Blogs, portfolios, and documentation sets are often (but not _always_) static sites. | Astro, Hugo, Docusaurus, Next.js [static exports](https://nextjs.org/docs/pages/building-your-application/deploying/static-exports) |

You can deploy either of these service types for free on Render.

**Free web services "spin down" after 15 minutes of inactivity.**
They spin back up when they next receive an incoming HTTP request or new WebSocket connection. Learn more about [free instance limitations](/content/docs/free/index.html).

## 4. Deploy your code

You can deploy using the Render Dashboard, the Render CLI, or a coding agent like Codex or Claude Code.

Select the tab for your preferred deployment method:

### 1. Connect your repo

1. In the [Render Dashboard](https://dashboard.render.com/), click **\+ New** in the top-right corner and select **Web Service** or **Static Site**:

The service creation form appears, showing a list of all the repos you have access to:

If you haven't connected your Git provider yet, you can do so from this form.

2. Select the repo that contains your web app and click **Connect**.

The rest of the creation form appears.

### 2. Configure deployment

Complete the service creation form to define how Render will build and run your app.

Click the tab for your service type to view important field details:

#### Web service fields

| Field | Description |
| --- | --- |
| **Branch** | Your service only deploys commits on the Git branch you specify, such as `main`.<br>Render can automatically redeploy your app whenever you push changes to this branch. |
| **Root Directory** | Deploying from a monorepo? Specify the subdirectory that represents your application root. Your build and start commands will run from this directory. |
| **Language** | If your app's programming language isn't listed in this dropdown, you can still deploy using the `Docker` runtime if you build your app from a `Dockerfile`. |
| **Build Command** | This is the command that Render will use to build your app from source and install dependencies.<br>Common examples include:<br>Node.js<br>Python<br>Ruby

```bash
npm install
```

You can also use `bun` or `yarn`.

```bash
pip install -r requirements.txt
```

You can also use `uv` or `poetry`. To use `uv`, your project must include a `uv.lock` file.

```bash
bundle install
```

This usually resembles the command you run locally to install dependencies and perform any necessary compilation. |
| **Start Command** | This is the command that Render will use to start your app.<br>Common examples include:<br>Node.js<br>Python<br>Ruby

```bash
npm start
```

You can also use `bun` or `yarn`.

```bash
gunicorn your_application.wsgi
```

```bash
./bin/rails server
```

For some frameworks, this might differ from the command you run locally to start your app. For example, a Flask app might use `flask run` locally but `gunicorn` for production. |
| **Compute** | This determines your service's CPU and RAM, along with its cost.<br>Choose the **Free** compute plan to deploy for free:<br> |
| **Environment Variables** | These will be available to your service at both build time and runtime.<br>If you forget any, you can always add them later and redeploy. |

#### Static site fields

| Field | Description |
| --- | --- |
| **Branch** | Your site only deploys commits on the branch you specify, such as `main`. Render can automatically redeploy whenever you push changes to this branch. |
| **Root Directory** | Deploying from a monorepo? Specify the subdirectory that represents your application root. Your build command will run from this directory. |
| **Build Command** | This is the command that Render will use to install dependencies and then build your site's static assets.<br>Common examples include:<br>Next.js / Astro / Vue.js<br>Jekyll

```bash
npm install && npm run build
```

For Next.js, make sure you've set [`output: 'export'`](https://nextjs.org/docs/pages/building-your-application/deploying/static-exports#configuration) in your `next.config.js` file.

```bash
bundle install && bundle exec jekyll build
```
| 
| **Publish Directory** | This is the directory containing your site's static assets, which are usually generated by your build command.<br>Common examples include:<br>- `build` (Create React App, Vue.js, etc.)<br>- `out` (Next.js static export)<br>- `_site` (Jekyll) |
| **Environment Variables** | These will be available to your service at build time.<br>Additionally, some static site generators substitute environment variable values into your generated static assets. For example:<br>- Create React App performs environment variable substitution for variables prefixed with `REACT_APP_`.<br>- Next.js does the same for variables prefixed with `NEXT_PUBLIC_`.<br>If you forget any, you can always add them later and redeploy. |

When you're done, click the **Deploy** button at the bottom of the form.

That's it! Render creates your service and kicks off your first deploy.

### 1. Install the CLI

Use any of the following methods to install the Render CLI or upgrade to the latest version:

##### Homebrew installation

Run the following commands:

```shell
$ brew update
$ brew install render
```

##### WinGet installation

Run the following command:

```shell
$ winget install render.cli
```

##### Installing with `curl`

Run the following command:

```shell
$ curl -fsSL https://raw.githubusercontent.com/render-oss/cli/refs/heads/main/bin/install.sh | sh
```

##### Direct download

1. Open the CLI's [GitHub releases page](https://github.com/render-oss/cli/releases/).
2. Download the executable that corresponds to your system's architecture.

If you use an architecture besides those provided, you can build from source instead.

##### Building from source

We recommend building from source only if no other installation method works for your system.

1. [Install the Go programming language](https://golang.org/doc/install) if you haven't already.
2. Clone and build the CLI project with the following commands:

```shell
$ git clone git@github.com:render-oss/cli.git
$ cd cli
$ go build -o render
```

After installation completes, open a new terminal tab and run `render` with no arguments to confirm.

### 2. Log in

Run the following command to authenticate:

```shell
$ render login
```

Your browser opens a confirmation page. Click **Authorize CLI**, then return to your terminal and select your workspace when prompted.

For details, see the [CLI setup guide](/content/docs/cli#setup/index.html).

### 3. Create a service

Use `render services create` to create and deploy a new service via the Render CLI. For example, the following command deploys a Node.js web service:

```shell
$ render services create \
    --name express-hello-world-example \
    --type web_service \
    --repo https://github.com/render-examples/express-hello-world \
    --runtime node \
    --build-command "npm install" \
    --start-command "npm start" \
    --plan free
```

Select the tab for your service type to learn which CLI options to supply:

#### Web Service

| Option | Description |
| --- | --- |
| `--name` | A name for your service (appears in the Dashboard and your `onrender.com` URL). |
| `--type` | Set to `web_service`. |
| `--repo` | The Git repository URL for your app. For private repos, first connect your Git provider account. |
| `--runtime` | Your app's runtime environment (`node`, `python`, `ruby`, `go`, or `elixir`). You can also use `docker` to build your app from a `Dockerfile`. |
| `--build-command` | This is the command that Render will use to build your app from source and install dependencies.<br>Common examples include `npm install`, `pip install -r requirements.txt`, and `bundle install`.<br>This command resembles the command you run locally to install dependencies and perform any necessary compilation. |
| `--start-command` | This is the command that Render will use to start your app.<br>Common examples include `npm start` and `bundle exec puma`.<br>For some frameworks, this might differ from the command you run locally. For example, a Flask app might use `flask run` locally but `gunicorn` for production. |
| `--env-var` | Environment variables are available to your service at both build time and runtime.<br>Repeat the flag for multiple variables. If you forget any, you can always add them later and redeploy. |
| `--plan` | Determines your service's CPU and RAM, along with its cost. Provide `free` to deploy this service for free. |

For the full list of options, see the [`services create` reference](/content/docs/cli-reference#services-create/index.html).

#### Static Site

| Option | Description |
| --- | --- |
| `--name` | A name for your site (appears in the Dashboard and your `onrender.com` URL). |
| `--type` | Set to `static_site`. |
| `--repo` | The Git repository URL for your site. For private repos, first connect your Git provider account. |
| `--build-command` | This is the command that Render will use to install dependencies and build your site's static assets.<br>Common examples include `npm install && npm run build` and `bundle install && bundle exec jekyll build`.<br>This command resembles the command you run locally to install dependencies and build your site. |
| `--publish-directory` | The directory containing your built static assets, usually generated by your build command.<br>Common examples include:<br>- `build` (Create React App, Vue.js, etc.)<br>- `out` (Next.js static export)<br>- `_site` (Jekyll) |
| `--env-var` | Environment variables are available to your site at build time. Some static site generators substitute them into your generated assets, for example:<br>- Variables prefixed with `REACT_APP_` (Create React App)<br>- Variables prefixed with `NEXT_PUBLIC_` (Next.js)<br>Repeat the flag for multiple variables. If you forget any, you can always add them later and redeploy. |
| `--auto-deploy` | By default, Render automatically redeploys your site whenever you push to your linked branch. Set to `false` to disable automatic redeploys. |

For the full list of options, see the [`services create` reference](/content/docs/cli-reference#services-create/index.html).

That's it! After running `render services create`, Render creates your service and returns its ID. You'll use this ID to monitor your deploy in the next step.

## 5. Monitor your deploy

In the [Render Dashboard](https://dashboard.render.com/), open your new service's **Deploys** page to see a log explorer showing your deploy's progress:

Follow along as the deploy proceeds through your build and start commands.

- **If the deploy completes successfully,** the deploy's status updates to **Live** and you'll see log lines like these:

```bash
# Web service
==> Deploying...
==> Running 'npm start' # (or your start command)
==> Your service is live 🎉

# Static site
==> Uploading build...
==> Your site is live 🎉
```

- **If the deploy fails,** the deploy's status updates to **Failed**. Review the log feed to help identify the issue.
  - Also see [Troubleshooting Your Deploy](/content/docs/troubleshooting-deploys/index.html) for common solutions.
  - After you identify the issue, push a new commit to your linked branch. Render will automatically start a new deploy.

Stream your deploy's logs in real time with `render logs`:

```shell
$ render logs --resources srv-abc123 --tail
```

Follow along as the deploy proceeds through your build and start commands.

- **If the deploy completes successfully,** you'll see log lines like these:

```bash
# Web service
==> Deploying...
==> Running 'npm start' # (or your start command)
==> Your service is live 🎉

# Static site
==> Uploading build...
==> Your site is live 🎉
```

- **If the deploy fails,** review the log output to help identify the issue.
  - Also see [Troubleshooting Your Deploy](/content/docs/troubleshooting-deploys/index.html) for common solutions.
  - After you identify the issue, push a new commit to your linked branch. Render will automatically start a new deploy.

Prompt your coding agent to check on your deploy. For example:

> Show me the deploy status and logs for my-service

Your coding agent retrieves the deploy status and logs.

- **If the deploy completes successfully,** your coding agent reports the service as live and returns the URL to open it in your browser.

- **If the deploy fails,** ask your coding agent to help diagnose the issue:

> Why did the deploy for my-service fail?

Also see [Troubleshooting Your Deploy](/content/docs/troubleshooting-deploys/index.html) for common solutions. After fixing the issue, prompt your coding agent to redeploy, or push a new commit to your linked branch to trigger a redeploy automatically.

## 6. Open your app

After your app deploys successfully, you're ready to view it live.

Every Render web service and static site receives a unique `onrender.com` URL. You can find this URL on your service's page in the [Render Dashboard](https://dashboard.render.com/):

Click the URL to open it in your browser. Your service will serve the content for its root path.

**Congratulations!** You've deployed your first app on Render 🎉

## Next steps

### Connect a datastore

Render provides fully managed Postgres and Key Value instances for your data needs. Both provide a Free compute plan to help you get started.

**Free Render Postgres databases expire 30 days after creation.**

You can upgrade to a paid instance at any time to keep your data. Learn more about [free instance limitations](/content/docs/free/index.html).

Learn how to create datastores and connect them to your app:

- [Render Postgres databases](/content/docs/postgresql-creating-connecting#create-your-database/index.html)
- [Render Key Value instances](/content/docs/key-value#create-your-key-value-instance/index.html)

Paid services can also attach a [disk](/content/docs/disks/index.html) for persistence of local filesystem data (by default, local filesystem changes are [lost with each deploy](/content/docs/deploys#ephemeral-filesystem/index.html)).

### Install the Render CLI

The Render CLI helps you manage your Render services right from your terminal. Trigger deploys, view logs, initiate psql sessions, and more.

[Get started with the Render CLI](/content/docs/cli/index.html).

### Add a custom domain

Each Render web service and static site receives its own `onrender.com` URL. You can also add your own custom domains to these service types. [Learn how](/content/docs/custom-domains/index.html).

### Learn about operational controls

Deploying your app is just the beginning. Check out a few of the ways you can manage and monitor your running services on Render:

- [Scaling your instance count](/content/docs/scaling/index.html)
- [Analyzing service metrics](/content/docs/service-metrics/index.html)
- [Rolling back a deploy](/content/docs/rollbacks/index.html)
- [Enabling maintenance mode](/content/docs/maintenance-mode/index.html)

Note that some of these capabilities require running your service on a paid compute plan.

### Explore other service types

In addition to supporting web services and static sites, Render offers a variety of other service types to support any use case:

| Service type | Description |
| --- | --- |
| [**Private services**](/content/docs/private-services/index.html) | Run servers that aren't reachable from the public internet. |
| [**Background Workers**](/content/docs/background-workers/index.html) | Offload long-running and computationally expensive tasks from your web servers. |
| [**Cron Jobs**](/content/docs/cronjobs/index.html) | Run periodic tasks on a schedule you define. |
| [**Workflows**](/content/docs/workflows/index.html) | Define collections of composable, long-running tasks that execute across distributed compute. |

Note that free instances are not available for these service types.