Logo

RESTful using postman

A Node.js and MySQL REST API for car records, tested end-to-end with Postman and CRUD workflows.

GitHub
JavaScript
RESTful using postman

#Project context

This project was my hands-on introduction to building a full CRUD REST API with a relational database.

The target was clear: create endpoints for a car resource, connect them to MySQL, and test the full flow with Postman.

At the time, I was focused on one thing: understanding the full request lifecycle from HTTP call to SQL execution and back to JSON response.

#Tech stack

  • Node.js
  • Express
  • MySQL (mysql package)
  • Postman for endpoint validation
  • SQL procedures in forcars.sql

The API listens on port 3000 and connects to a local MySQL database called forcars.

#Endpoints implemented

The API includes the core CRUD operations:

  • GET /cars -> list all cars
  • GET /cars/:id -> fetch one car by carID
  • POST /cars -> create a new car (through carAdd() procedure)
  • PUT /cars -> update a car (through carEdit() procedure)
  • DELETE /cars/:id -> delete by carID

I intentionally kept the route design simple so I could focus on query correctness and data flow.

#How data moves through the app

When a request hits an endpoint, Express parses JSON body data, then calls MySQL queries with parameter binding.

For create and update, I used stored procedures instead of inline SQL. This was useful for learning separation of concerns:

  • API layer handles transport and request parsing.
  • Database layer handles insert/update rules.

The request-response cycle looks like this:

  1. Postman sends HTTP request.
  2. Express route handler receives params/body.
  3. MySQL query or procedure executes.
  4. API returns JSON message or result set.

Seeing this loop work reliably was the moment backend development started to feel real for me.

#What I learned while debugging

#1. Connection setup is half the job

The app prints Connected to Database! when successful. If that message did not appear, endpoint testing was pointless.

I learned to verify infrastructure first, then application logic.

#2. Input shape matters

For POST and PUT, body fields had to match expected keys exactly (type, brand, license_plate, and carID for update). Small naming mismatches caused silent confusion.

#3. SQL and API should speak the same language

I had to keep field names and procedure parameters aligned between JavaScript and MySQL. Once they drift, debugging becomes guesswork.

#4. Postman is not just for demos

Using Postman systematically made testing faster:

  • Happy path calls
  • Missing field cases
  • Invalid ID scenarios
  • Repeated updates and deletes

It gave me confidence that behavior was consistent, not accidental.

#Notable implementation details

A few points in the code are worth calling out:

  • express.json() and express.urlencoded() are enabled so body parsing is stable.
  • Parameterized SQL is used for ID-based routes to reduce injection risk.
  • Stored procedures (carAdd, carEdit) are invoked with multi-statement queries.

This project is early-stage code, so there are places I would harden now, but the structure taught the right fundamentals.

#If I rebuilt this today

I would keep the same scope and improve production readiness:

  • Move DB credentials to environment variables (.env)
  • Replace raw callback patterns with async/await
  • Add schema validation with zod or joi
  • Return consistent HTTP status codes and error objects
  • Add integration tests with a test database
  • Containerize API + DB with Docker Compose

I would also split routes/controllers/services for cleaner code organization as the API grows.

#Why this project still matters in my portfolio

This is a small backend project, but it shows core engineering behavior:

  • Build minimal, complete functionality
  • Validate it through explicit API tests
  • Learn from operational and schema mismatches
  • Improve iteration by iteration

For junior backend roles, that process matters more than writing a very large codebase once.

#SEO relevance

If you are searching for a Node.js REST API with MySQL and Postman example, this project is a practical starting point. It covers core CRUD patterns, stored procedure integration, and end-to-end request testing without overcomplicating the stack.

It is useful for students and early-career developers who want a project they can understand, run locally, and extend.

#Repository

Source code and SQL script are available here:

GitHub repository