Skip to content
  • Backend
  • Projects

Backend projects for beginners

Good backend projects for beginners prove you can handle bad data and failures as well as return JSON. Build a REST API on PostgreSQL, a login service with properly hashed passwords, a payment webhook that verifies signatures and ignores duplicates, a rate-limited URL shortener and a background job queue. Deploy each one and write tests.

By the DevIt teamPublished 5 min read

What a backend project has to show

A reviewer can't see a backend in a browser, so your project has to show its quality in the code and the README. They look for clean routes, correct status codes, validated input and errors that don't crash the server.

Use a real database from the first project. PostgreSQL was used by 55.6% of all respondents and 58.2% of professional developers in the Stack Overflow Developer Survey 2025, so it's the safe default to learn.

Each project below adds one thing that tutorial APIs skip. By the end you'll have code you can walk an interviewer through line by line.

Five backend projects for beginners

Build them in order. Each one reuses the setup from the last, so the later ones go faster.

ProjectWhat it provesThe detail that matters
Notes API on PostgreSQLCRUD, validation, status codes400 for bad input, 404 for missing rows, never a 500 for a user mistake
Login serviceAuthentication and password storagePasswords hashed with Argon2id or bcrypt, never stored or logged in plain text
Payment webhook receiverSecurity and idempotencySignature checked on the raw body, duplicate events ignored
URL shortener with rate limitsAbuse handling and cachingReturns 429 with a Retry-After header when a client sends too much
Background job workerAsync work and concurrencyTwo workers never pick up the same job

The webhook project is the one beginners rarely have. It's also close to everyday work at any Indian startup that takes payments through a gateway such as Razorpay.

Store passwords the way OWASP recommends

Use a slow, salted hash built for passwords. OWASP's Password Storage Cheat Sheet puts Argon2id first, with a minimum of 19 MiB of memory, 2 iterations and 1 degree of parallelism.

If your library only offers bcrypt, OWASP says to use "a work factor of 10 or more". It also warns that bcrypt has a 72-byte input limit in most implementations, so reject longer passwords instead of letting them get cut off silently.

Write one test for the login route that checks a wrong password and an unknown email return the same error message. Different messages tell an attacker which emails have accounts.

Verify a payment webhook the way Razorpay expects

Razorpay signs every webhook so you can prove it came from them. Its webhook documentation says the signature arrives in the X-Razorpay-Signature header, is an HMAC SHA256 of the raw request body using your webhook secret, and warns: "Do not parse or cast the webhook request body."

The same page says your endpoint "might receive the same webhook event multiple times", and that you can spot repeats with the x-razorpay-event-id header. Here's a receiver that handles both, using Razorpay's test mode:

webhook.jsjavascript
import crypto from "node:crypto";
import express from "express";

const app = express();
const processed = new Set(); // use a database table with a unique key in a real app

app.post("/webhooks/razorpay", express.raw({ type: "application/json" }), (req, res) => {
  const expected = crypto
    .createHmac("sha256", process.env.RAZORPAY_WEBHOOK_SECRET)
    .update(req.body) // the raw Buffer, not parsed JSON
    .digest("hex");
  const received = req.get("X-Razorpay-Signature") ?? "";

  const valid =
    received.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(received), Buffer.from(expected));
  if (!valid) return res.status(400).send("invalid signature");

  const eventId = req.get("x-razorpay-event-id");
  if (processed.has(eventId)) return res.status(200).send("already processed");
  processed.add(eventId);

  const event = JSON.parse(req.body.toString("utf8"));
  // mark the order paid using event.payload, then respond quickly
  return res.status(200).send("ok");
});

In an interview, explain why each line exists. Parsing the JSON before hashing changes the bytes, so the signature check fails. Returning 200 for a duplicate acknowledges it without recording the same payment twice.

Build a job queue in PostgreSQL

You don't need a separate queue service for your first worker. PostgreSQL can hand each job to exactly one worker with a row lock.

The PostgreSQL documentation says SKIP LOCKED skips rows another transaction has locked, which "can be used to avoid lock contention with multiple consumers accessing a queue-like table". Each worker runs this inside a transaction:

claim_job.sqlsql
UPDATE jobs
SET status = 'running', started_at = now()
WHERE id = (
  SELECT id FROM jobs
  WHERE status = 'pending'
  ORDER BY created_at
  LIMIT 1
  FOR UPDATE SKIP LOCKED
)
RETURNING id, payload;

Use it to send emails or generate PDF invoices after an order. Then run two workers at once and show in your README that no job ran twice.

Rate limits and the 429 status code

A URL shortener gets abused fast, so it's a natural place to add limits. Count requests per IP address or API key in a sliding window, and reject the excess.

MDN defines 429 Too Many Requests as the status for a client that "has sent too many requests in a given amount of time", and notes that a Retry-After header "may be included" to say how long to wait (MDN Web Docs). Send that header, and write a test that fires 101 requests at a 100-request limit.

Test the API like a reviewer would

Tests are the part of a backend project that reviewers check and beginners skip. You don't need many, but they should hit the cases that break real APIs.

Write integration tests that start the server against a separate test database, send real HTTP requests and check the status code and body. One test per status code your API can return is a good floor: 200, 201, 400, 401, 404, 409 and 429 for the projects above.

Reset the test database before each run so tests don't depend on each other's leftovers. Then add the command that runs them to your README, along with how long the suite takes, so a reviewer can run it in one step.

Building these with DevIt's Backend internship

If you want deadlines and graded submissions for this list, DevIt's Backend Development Internship follows a similar path. It expects basic JavaScript, a terminal and Git, and uses Node.js, Express, PostgreSQL and Prisma.

The 1-month plan includes a file-backed todo CLI, an in-memory REST API and a persistent REST API on PostgreSQL with Prisma. The 3-month plan adds a JWT authentication service, a URL shortener, a background job and email queue worker, a real-time chat API and a production-grade capstone, plus a sliding-window rate limiter exercise.

It's a paid training internship with no stipend: on 15 November 2026 the 1-month plan cost ₹199 at its Early Bird price. Every track is on the internships page, and if you're still choosing a side, read frontend vs backend developer.

Frequently asked questions

Which language should I use for my first backend project?

Use the one you already write. Node.js with Express suits you if you know JavaScript, and Python or Java work just as well. In a code review, how you handle data and errors says more than the language.

Should I use an ORM or write SQL by hand?

Write raw SQL for your first project so you understand joins and indexes, then use an ORM such as Prisma for the rest. Be ready to show the SQL your ORM generates for one slow query.

How many backend projects do I need for an internship?

Two or three finished, deployed projects with tests and a clear README are enough for most applications. One of them should handle something beyond CRUD, such as webhooks, a queue or rate limits.

Do I need Docker for beginner backend projects?

Not at first. Add a Dockerfile once your API works, because it lets a reviewer run your project with one command and shows you understand how it's deployed.

Survey figures, documentation and DevIt track details checked 15 November 2026.