Bolt.new AI and PostgreSQL integration: Step-by-Step Guide 2025

To integrate Bolt.new with PostgreSQL, you don’t connect “Bolt” itself to a database — instead, you create a backend inside Bolt.new (usually a Node.js/Express server or similar) and that backend connects to PostgreSQL using a real database driver such as pg. You store the database credentials in Bolt.new environment variables, initialize a database client in your server code, and then your AI-powered frontend or API routes can read/write data through that connection. It works exactly like a normal full‑stack app: Bolt gives you a browser-based workspace, but your backend runs in a container where you can install npm packages and talk to external services over the network. PostgreSQL must be reachable (e.g., Neon, Supabase, RDS, or a local Postgres exposed through a tunnel).

 

What integration really means

 

Bolt.new doesn’t have a built‑in database module. It simply runs your server code. Connecting to PostgreSQL means:

• You install a Postgres client library (most common is pg).
• You define environment variables for host, port, username, password, and database name.
• Your backend code creates a connection pool (a reusable set of connections).
• Your API routes call SQL queries using that pool.

This is the exact same structure you would use on Vercel, Render, Railway, or local development — Bolt just makes the iteration loop faster.

 

Step-by-step integration inside Bolt.new

 

• Create or choose a backend folder in your Bolt workspace (e.g., /api or /server).
• Install the PostgreSQL driver:

npm install pg

• Define environment variables inside Bolt.new’s env panel (right sidebar):

POSTGRES_HOST=your-db-host
POSTGRES_PORT=5432
POSTGRES_USER=your-user
POSTGRES_PASSWORD=your-password
POSTGRES_DB=your-db-name

• Create a connection pool in your backend code:

// server/db.js
// Reusable PostgreSQL connection pool using the pg library

import pkg from "pg";
const { Pool } = pkg;

export const db = new Pool({
  host: process.env.POSTGRES_HOST,
  port: Number(process.env.POSTGRES_PORT),
  user: process.env.POSTGRES_USER,
  password: process.env.POSTGRES_PASSWORD,
  database: process.env.POSTGRES_DB
});

• Add an API endpoint that queries the database:

// server/routes/users.js
// Example Express route that reads data from PostgreSQL

import express from "express";
import { db } from "../db.js";

const router = express.Router();

router.get("/users", async (req, res) => {
  try {
    const result = await db.query("SELECT id, name FROM users"); // simple query
    res.json(result.rows);
  } catch (err) {
    console.error("DB error:", err);
    res.status(500).json({ error: "Database failure" });
  }
});

export default router;

• Wire the route into your server:

// server/index.js
// Minimal Express server used inside Bolt.new

import express from "express";
import usersRoute from "./routes/users.js";

const app = express();

app.use("/api", usersRoute);

app.listen(3000, () => {
  console.log("Backend running on port 3000");
});

• Test your endpoint inside Bolt’s built‑in browser or using fetch from the frontend:

// frontend example fetch call

const res = await fetch("/api/users");
const data = await res.json();
console.log(data);

 

Choosing the PostgreSQL provider

 

You can connect to any real PostgreSQL instance as long as it is reachable from the internet. Common choices:

• Neon (serverless, easy free tier)
• Supabase Postgres
• Railway Postgres
• AWS RDS / Azure Postgres / GCP Cloud SQL

All of these give you a connection string, which you break into environment variables as shown above.

 

Important practical notes

 

• Bolt.new containers restart when you change code — always use a Pool, never single connections.
• Your DB must allow external connections (enable public networking or set up a proxy/tunnel).
• Never hard‑code passwords. Use environment variables always.
• Long-running queries or heavy migrations should be done outside Bolt, using your local machine or the provider CLI.

 

The bottom line

 

Integrating Bolt.new with PostgreSQL is simply running a normal Node backend inside Bolt and pointing it at a real Postgres database using the pg library and environment variables. Nothing custom, nothing magic — just standard, production‑ready database usage executed inside Bolt’s workspace.