How to Build a Blog backend with Replit

To build a simple yet real blog backend on Replit, create a Node.js + Express project, set up routes for posts, and connect it to a persistent database like Replit’s built-in SQLite. Replit automatically gives you a web URL for your Express app, so you can test API endpoints instantly. You’ll store secrets (like API keys) in the “Secrets” tab, organize the code into separate files (server, routes, and database logic), and make sure everything restarts cleanly when the server updates.

 

Step 1: Create a Node.js Repl

 

In Replit’s dashboard, click “+ Create Repl”, select “Node.js” template. Replit will generate index.js by default. This file is where your server code goes.

 

// index.js
const express = require("express");
const bodyParser = require("body-parser");
const Database = require("@replit/database"); // Simple key-value store built into Replit!

const app = express();
app.use(bodyParser.json());

const db = new Database(); // Connect to Replit DB

// Test route - you can visit this in browser
app.get("/", (req, res) => {
  res.send("Blog backend is running!");
});

// Start server
app.listen(3000, () => console.log("Server live on port 3000"));

 

Click “Run” — Replit boots the server and gives you a URL like https://your-repl-name.username.repl.co. That’s your live backend endpoint.

 

Step 2: Create a directory for routes

 

In your file tree on the left, right-click and select “New Folder” → name it `routes`. Inside it, create a new file called posts.js. This keeps your code modular.

 

// routes/posts.js
const express = require("express");
const router = express.Router();
const Database = require("@replit/database");
const db = new Database();

// Create a post
router.post("/", async (req, res) => {
  const { title, content } = req.body;
  if (!title || !content) return res.status(400).send("Missing title or content");
  
  const id = Date.now().toString(); // Unique ID based on timestamp
  await db.set(id, { id, title, content });
  res.send({ id, title, content });
});

// Get all posts
router.get("/", async (req, res) => {
  const keys = await db.list();
  const posts = [];
  for (let key of keys) {
    const post = await db.get(key);
    posts.push(post);
  }
  res.send(posts);
});

// Get single post
router.get("/:id", async (req, res) => {
  const post = await db.get(req.params.id);
  if (!post) return res.status(404).send("Post not found");
  res.send(post);
});

// Delete post
router.delete("/:id", async (req, res) => {
  await db.delete(req.params.id);
  res.send({ message: "Post deleted" });
});

module.exports = router;

 

Step 3: Connect routes to your server

 

Now open index.js again and import that route file.

 

// index.js (add this near the top)
const postsRoute = require("./routes/posts");

// Below your existing middleware (after app.use(bodyParser.json()))
app.use("/api/posts", postsRoute);

 

This means that when you visit /api/posts in the browser or with a tool like Postman, your new routes will respond. For example:

• GET /api/posts → get all blog posts
• POST /api/posts → create new post (send JSON: { title, content })
• GET /api/posts/:id → fetch post by ID
• DELETE /api/posts/:id → remove a post

 

Step 4: Store secrets safely

 

If later you want to connect to an external database (like MongoDB), go to the “Secrets” (🔒 icon on left sidebar) and add your MONGODB\_URI variable instead of writing it directly into the file. Then access it as:

 

const mongoUri = process.env.MONGODB_URI;

 

This avoids exposing passwords in your code or public Repls.

 

Step 5: Understand Replit behavior

 

• Auto-restarts: Replit restarts your server every time you change code. That’s normal — just save often.
• Package installs: When you type require(), Replit may prompt to auto-install; say yes or run npm install express body-parser @replit/database in shell.
• Persistent data: Replit DB persists between runs, but deleting the Repl or renaming it can lose data. For production, migrate to an external DB.
• Testing endpoints: Use the “Webview” pane on right or external tools like curl/Postman for easier debugging.

 

Step 6: Deploying properly

 

Replit projects stay live while the tab is open. For a semi-permanent setup, use Replit’s “Always On” feature (Pro accounts) or connect to an external uptime monitor (like UptimeRobot hitting your main endpoint to keep it alive).

 

Summary

 

You’ve got a working backend that supports basic CRUD (Create, Read, Delete) operations for blog posts using Express and Replit’s built-in database. The key idea is to organize your server entry point (index.js), define API routes in routes/posts.js, and let Replit’s URL serve as your live endpoint. This is a stable, realistic way to build a blog backend right inside Replit’s free or pro environment — no fake tools, just real working components.

A solid and realistic way to build a blog backend on Replit is to create a small Node.js and Express app that exposes routes (for example /posts to fetch blog posts, /admin to add new posts). You store posts in a simple SQLite database (which fits perfectly in Replit) or in a JSON file if you’re just starting. You’ll use Replit’s built-in “Secrets” system for any API keys or database credentials, and Replit’s “Always On” or external deployment (like using Replit Deployments or hosting elsewhere) if you want the backend reachable 24/7. The best practice is to keep your server code organized: one server.js to start the app, one routes/ folder for API endpoints, and one db.js for your database logic. Avoid expecting Replit’s ephemeral filesystem to keep data safe across restarts — always persist important data in SQLite or an external database.

 

Step-by-step Setup

 

Create a new Repl: choose the “Node.js” template. Replit will make a default index.js. Rename it to server.js for clarity.

• In sidebar, click the “Add file” button and create a server.js.
• Delete or ignore index.js after renaming if it exists.

 

Install dependencies

 

npm install express sqlite3 cors

 

Explanation:

• express – web framework for routes
• sqlite3 – lightweight local database engine (perfect for Replit)
• cors – enables your frontend to call your backend safely

 

Basic Express server (in server.js)

 

// server.js
const express = require('express')
const cors = require('cors')
const app = express()
const PORT = process.env.PORT || 3000

app.use(cors())
app.use(express.json()) // allows JSON bodies in requests

app.get('/', (req, res) => {
  res.send('Blog backend is running!')
})

app.listen(PORT, () => console.log(`Server running on port ${PORT}`))

Click the green “Run” button on Replit, then open the Replit webview link. You’ll see “Blog backend is running!”. That’s your basic backend.

 

Add a Database File

 

Add a new file named db.js in the root of your Repl. This will handle SQLite connections. A database.db file will be created automatically when you first run the app.

 

// db.js
const sqlite3 = require('sqlite3').verbose()

// Create or open the database
const db = new sqlite3.Database('./database.db', (err) => {
  if (err) console.error('Database failed to open', err)
  else console.log('Connected to SQLite database')
})

// Create a table for posts if it doesn't exist
db.run(`CREATE TABLE IF NOT EXISTS posts (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  title TEXT,
  content TEXT,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)`)

module.exports = db

 

Create API Routes

 

Add a new folder named routes and inside it, create a file called posts.js. You’ll separate your routes — this keeps server.js clean.

 

// routes/posts.js
const express = require('express')
const router = express.Router()
const db = require('../db')

// GET all posts
router.get('/', (req, res) => {
  db.all('SELECT * FROM posts ORDER BY created_at DESC', [], (err, rows) => {
    if (err) return res.status(500).json({ error: err.message })
    res.json(rows)
  })
})

// POST a new blog post
router.post('/', (req, res) => {
  const { title, content } = req.body
  if (!title || !content) return res.status(400).json({ error: 'Missing fields' })
  db.run('INSERT INTO posts (title, content) VALUES (?, ?)', [title, content], function(err) {
    if (err) return res.status(500).json({ error: err.message })
    res.json({ id: this.lastID })
  })
})

module.exports = router

 

Connect Routes to the Server

 

Go back to server.js and mount your routes:

 

// server.js
const express = require('express')
const cors = require('cors')
const app = express()
const PORT = process.env.PORT || 3000

app.use(cors())
app.use(express.json())

// Import and use the posts router
const postsRouter = require('./routes/posts')
app.use('/posts', postsRouter)

app.listen(PORT, () => console.log(`Server running on port ${PORT}`))

 

Use Replit Secrets

 

For any sensitive data (API keys, database URLs, admin passwords), never hardcode them in files. Go to the Replit sidebar → “Secrets” (lock icon), add new keys (for example ADMIN\_TOKEN), and access them in your code like this:

 

const adminToken = process.env.ADMIN_TOKEN

 

Common Replit Gotchas

 

• Replit restarts Repls – SQLite data persists within the Repl’s filesystem, but not guaranteed forever. For production-level projects, back up your database.db or switch to a remote DB (like Supabase).
• Always use Replit Secrets – Never add secret tokens or passwords directly into your code files.
• Don’t rely on Replit file watchers for heavy tasks – keep scripts and DB initialization lightweight so it starts fast.
• Use proper folder structure – routes/, db.js, and server.js separation helps clarity and easier debugging.
• Enable “Always On” or Deploy in Replit if you want API accessible continuously. Otherwise, the Repl sleeps after inactivity.

 

Testing Your Blog Backend

 

Use your browser or a tool like curl or Postman.

 

curl -X POST https://<your-repl-name>.<your-username>.repl.co/posts \
  -H "Content-Type: application/json" \
  -d '{"title": "My first post", "content": "Hello from Replit!"}'

 

Then open /posts from the Replit Webview to see the stored data. You now have a functional, persistent blog backend built the clean way inside Replit.