Drizzle with Bun and PostgreSQL on Railway

Create a Railway project

Log in to your Railway dashboard and click the New Project button.

Provision a PostgreSQL database

On the project canvas, click the New button in the top right corner and select Database → PostgreSQL. You can also use the command palette (Cmd/Ctrl + K) and search for PostgreSQL. Railway will provision a new PostgreSQL instance for you.

Get your connection string

Click on the PostgreSQL service in your project, go to the Variables tab, and find the DATABASE_PUBLIC_URL variable. Copy the value — it should look similar to this:

postgresql://postgres:[email protected]:port/railway

Setup connection string variable

Create a .env file in the root of your project and add the DATABASE_URL environment variable. Use the public connection string from Railway:

DATABASE_URL=postgresql://postgres:[email protected]:port/railway

Connect Drizzle ORM to your database

Create a db.ts file and set up your database configuration:

import { drizzle } from "drizzle-orm/node-postgres";

export const db = drizzle(process.env.DATABASE_URL!);

Create tables

Create a schema.ts file and declare your tables:

import * as p from "drizzle-orm/pg-core";

export const usersTable = p.pgTable("users", {
  id: p.serial().primaryKey(),
  name: p.text().notNull(),
  age: p.integer().notNull(),
  email: p.text().notNull().unique(),
});

export const postsTable = p.pgTable("posts", {
  id: p.serial().primaryKey(),
  title: p.text().notNull(),
  content: p.text().notNull(),
  userId: p
    .integer()
    .notNull()
    .references(() => usersTable.id, { onDelete: "cascade" }),
  createdAt: p.timestamp().notNull().defaultNow(),
  updatedAt: p
    .timestamp()
    .notNull()
    .$onUpdate(() => new Date()),
});

export type InsertUser = typeof usersTable.$inferInsert;
export type SelectUser = typeof usersTable.$inferSelect;

export type InsertPost = typeof postsTable.$inferInsert;
export type SelectPost = typeof postsTable.$inferSelect;

Setup Drizzle config file

Drizzle config - a configuration file that is used by Drizzle Kit and contains all the information about your database connection, migration folder and schema files.

Create a drizzle.config.ts file in the root of your project and add the following content:

import { defineConfig } from "drizzle-kit";

export default defineConfig({
  schema: "./src/schema.ts",
  out: "./migrations",
  dialect: "postgresql",
  dbCredentials: {
    url: process.env.DATABASE_URL!,
  },
});

Applying changes to the database

You can generate migrations using drizzle-kit generate command and then run them using the drizzle-kit migrate command.

Generate migrations:

bunx drizzle-kit generate

The generate command only creates migration SQL files based on your schema — it does not apply any changes to the database. These migrations are stored in the migrations directory, as specified in your drizzle.config.ts. This directory will contain the SQL files necessary to update your database schema and a meta folder for storing snapshots of the schema at different migration stages.

Example of a generated migration:

CREATE TABLE "posts" (
	"id" serial PRIMARY KEY NOT NULL,
	"title" text NOT NULL,
	"content" text NOT NULL,
	"userId" integer NOT NULL,
	"createdAt" timestamp DEFAULT now() NOT NULL,
	"updatedAt" timestamp NOT NULL
);
--> statement-breakpoint
CREATE TABLE "users" (
	"id" serial PRIMARY KEY NOT NULL,
	"name" text NOT NULL,
	"age" integer NOT NULL,
	"email" text NOT NULL,
	CONSTRAINT "users_email_unique" UNIQUE("email")
);
--> statement-breakpoint
ALTER TABLE "posts" ADD CONSTRAINT "posts_userId_users_id_fk" FOREIGN KEY ("userId") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;

Apply the generated migrations to the database:

bunx drizzle-kit migrate

Alternatively, you can push changes directly to the database using Drizzle kit push command:

bunx drizzle-kit push

Prepare your project for deployment

Once you’ve generated your migrations, commit the migrations directory to your repository — these files will be applied automatically when your app starts.

Create an index.ts file as the entry point for your application. This example runs migrations on startup and then starts a simple HTTP server using Bun:

import { drizzle } from "drizzle-orm/node-postgres";
import { migrate } from "drizzle-orm/node-postgres/migrator";
import { usersTable } from "./schema";

const db = drizzle(process.env.DATABASE_URL!);

await migrate(db, { migrationsFolder: "./migrations" });

const server = Bun.serve({
  port: process.env.PORT || 3000,
  async fetch(req) {
    const url = new URL(req.url);

    if (url.pathname === "/users") {
      const users = await db.select().from(usersTable);
      return new Response(JSON.stringify(users), {
        headers: { "Content-Type": "application/json" },
      });
    }

    return new Response("OK");
  },
});

console.log(`Server running on port ${server.port}`);

The migrate() function reads the SQL files from your migrations directory and applies any unapplied migrations to the database. It is safe to run on every startup — already applied migrations are skipped.

Make sure your package.json has a start script:

{
  "scripts": {
    "start": "bun src/index.ts"
  }
}

Push your project to GitHub

Railway deploys from a GitHub repository. Initialize a git repository and push your code:

git init
git add .
git commit -m "initial commit"

Create a new repository on GitHub and push your code to it.

Connect your GitHub repository to Railway

In your Railway project, click the New button in the top right corner of the canvas and select GitHub Repo. Connect your GitHub account if prompted, then select the repository you just pushed.

Configure environment variables

In the deployed service settings, go to the Variables tab. Add the DATABASE_URL variable by referencing the PostgreSQL service variable:

Click Add Variable, set the name to DATABASE_URL, and use the Railway variable reference ${{Postgres.DATABASE_URL}} as the value.

Deploy

Railway will automatically deploy your application when you push to the connected branch. You can monitor the deployment in the Deployments tab.

Verify your setup

Once deployed, navigate to the Architecture tab in your Railway project. You should see your application service connected to the PostgreSQL database.

bunx drizzle-kit migrate

Add a new service from a template

In your Railway project, click the New button in the top right corner of the canvas and select Template.

Select the Drizzle Studio template

Search for drizzle studio and select the Drizzle Studio template by Drizzle.

Configure environment variables and deploy

The template comes with two pre-configured environment variables:

• PASSCODE - the password for secure access to your Studio instance. It defaults to ${{secret()}}, which generates a random secret.
• DATABASE_URL - the database connection string. Set it to ${{Postgres.DATABASE_URL}} to reference your existing PostgreSQL service.

Click Deploy Template to deploy.

Find your Drizzle Studio URL

Once deployed, click on the Drizzle Studio service in your project, go to the Settings tab, and scroll down to the Networking section. You will find your public domain under Public Networking.

Browse your database with Drizzle Studio

Open the Drizzle Studio URL in your browser. You should see your database tables and can browse, filter, and edit data directly.

Verify your setup

Navigate to the Architecture tab in your Railway project. You should now see three services: your application, the PostgreSQL database, and Drizzle Studio.