How Postman Skills Boost Your Java Developer Job Search

// Postman — Tests tab for a Java Spring Boot endpoint
// e.g. GET {{baseUrl}}/api/v1/users/1

pm.test("status is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("response time under 500ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

pm.test("body has required fields", function () {
    const body = pm.response.json();
    pm.expect(body).to.have.property("id");
    pm.expect(body).to.have.property("email");
    pm.expect(body.email).to.match(/^[^@]+@[^@]+$/);
});

pm.test("content-type is JSON", function () {
    pm.expect(pm.response.headers.get("Content-Type"))
      .to.include("application/json");
});

// Postman — chaining requests with pre-request scripts
// Flow: login → fetch user → update profile

// 1. POST {{baseUrl}}/api/v1/auth/login
//    Pre-request: none
//    Tests:
pm.test("login returns token", function () {
    pm.response.to.have.status(200);
    const body = pm.response.json();
    pm.expect(body).to.have.property("token");
    pm.collectionVariables.set("authToken", body.token);
});

// 2. GET {{baseUrl}}/api/v1/users/me
//    Headers: Authorization: Bearer {{authToken}}
//    Tests:
pm.test("user returned", function () {
    pm.response.to.have.status(200);
    const body = pm.response.json();
    pm.expect(body.role).to.be.oneOf(["USER", "ADMIN"]);
});

// 3. PUT {{baseUrl}}/api/v1/users/me
//    Body:
//    { "displayName": "Ankit K" }
//    Tests:
pm.test("profile updated", function () {
    pm.response.to.have.status(200);
    pm.expect(pm.response.json().displayName)
      .to.eql("Ankit K");
});

# My Spring Boot API — with Postman collection

A small REST API built with Spring Boot, tested with Postman
and Newman, and shipped with GitHub Actions.

## Run the API

    ./mvnw spring-boot:run

## Test the API with Postman

1. Import `postman/java-api.postman_collection.json`
2. Import `postman/local.postman_environment.json`
3. Select the environment, then run the collection

## Run tests headlessly

    npm install -g newman
    newman run postman/java-api.postman_collection.json \
      -e postman/local.postman_environment.json \
      --reporters cli,json \
      --reporter-json-export reports/newman.json

## What the collection covers

- Auth: login → JWT → protected routes
- Users: create, read, update, delete (CRUD)
- Validation: 400 for bad payloads
- Security: 401 without token, 403 for wrong role

# .github/workflows/api-tests.yml
name: API tests

on: [push, pull_request]

jobs:
  newman:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Java 21
        uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: "21"

      - name: Start Spring Boot API
        run: |
          ./mvnw -q spring-boot:run &
          # wait for the app to be up
          npx wait-on http://localhost:8080/actuator/health

      - name: Install Newman
        run: npm install -g newman

      - name: Run Postman collection
        run: |
          newman run postman/java-api.postman_collection.json \
            -e postman/ci.postman_environment.json \
            --bail

30-day Postman plan — alongside your Java work

Week 1 — Requests & environments
  ☐ Install Postman and create a free account
  ☐ Send a GET to your local Spring Boot endpoint
  ☐ Try POST with a JSON body and Authorization header
  ☐ Create "dev" and "staging" environments
  ☐ Note: 20 minutes a day is enough

Week 2 — Collections & variables
  ☐ Save every request into a collection
  ☐ Create folders: auth, users, orders
  ☐ Use {{baseUrl}} and {{authToken}} variables
  ☐ Share the collection with a friend and get feedback

Week 3 — Tests & chaining
  ☐ Add status and schema assertions to every request
  ☐ Write a pre-request script to fetch a token
  ☐ Chain login → fetch → update in one collection
  ☐ Run the collection in the Postman runner

Week 4 — Newman & portfolio
  ☐ Install Newman: `npm install -g newman`
  ☐ Export collection + environment into your repo
  ☐ Add a GitHub Actions workflow that runs Newman
  ☐ Update your README and resume
  ☐ Record a 2-minute walkthrough video

Interview talking points — the "how did you test it?"
question

1. "What tool did you use to test your API?"
   → "Postman collections, run headlessly with Newman in CI."

2. "How did you handle authentication in your tests?"
   → "A pre-request script calls /login, stores the JWT in a
     collection variable, and subsequent requests use it in the
     Authorization header."

3. "How do you know your tests actually run?"
   → "GitHub Actions runs Newman on every push; the build fails
     if any assertion fails."

4. "What did Postman catch for you?"
   → "A 500 vs 400 regression when a validation annotation was
     removed — the collection's 400-assertion failed immediately."

5. "How would you scale this?"
   → "Split collections per service, use Newman in a matrix job,
     and publish reports as CI artefacts."