IDCamp 2024/Backend/course

Bookshelf API

Built in the IDCamp 2024 backend JavaScript track, this project is a compact API contract exercise focused on payload validation, response consistency, and reviewer clarity.

project links
Domain
Backend
Role
Backend Engineer
Output
Backend API
Category
CRUD API Contract
Project Framing

A source-backed case study built for recruiter review

This reading path makes the problem choice, evidence quality, user framing, execution decisions, and proof trail visible without overstating what the sources support.

Project Type
course

Hapi-based CRUD API project focused on consistent book payload rules, validation, filters, and reviewer-friendly API contracts.

Orientation
Tech

Shows that API quality can come from disciplined contracts, response consistency, and reviewer-ready validation assets rather than feature count alone.

Core Stack
Node.js · Hapi.js · nanoid · ESLint

Node.js service using Hapi route definitions and in-project handlers, with nanoid for identifiers and Postman collection/environment artifacts for API review.

Why This Problem Mattered

Problem framing before execution

The case-study layer starts with why this problem was selected and how the context justified investment.

Problem Framing Map

Issue

Even a compact CRUD API needs strict payload rules and predictable responses to avoid fragile client integration.

Context

This project was shaped as a contract-quality exercise inside the backend JavaScript track, where response consistency and reviewer clarity mattered more than broad feature scope.

Why Selected

It is useful in the portfolio because it shows that good backend judgment also appears in small systems through validation discipline and contract consistency.

Problem statement

A simple bookshelf service still needs strict request payload rules and predictable CRUD responses to avoid fragile client integration.

Solution thesis

Implemented a Hapi API with focused route handlers, book payload validation, list/detail/update/delete flows, and query filtering for name, reading, and finished states.

Research and Evidence

What supports the narrative

Evidence is surfaced with its source type and credibility note so the recruiter can quickly see what is directly backed versus intentionally constrained.

Contract baseline
local

The source-backed project narrative emphasizes payload validation, CRUD flow correctness, and practical query filtering.

Credibility: Supported by the project summary, problem framing, and responsibilities recorded from README-backed sources.
Reviewer validation artefacts
local

Postman collection and environment files are explicitly preserved as part of the project proof surface.

Credibility: Directly supported by the metrics and architecture description in the current project record.

Credibility Notes

  • The project is framed as API contract and correctness evidence, not as a complex distributed backend or deployed production service.
  • No scaling, persistence-hardening, or test-depth claim is added beyond what the current sources document.
Who The User Was

User framing stays explicit

When formal research artefacts are not available, the page still explains who the work served and why that user framing is justified by the existing sources.

Primary user
API consumers who need stable request and response behavior for bookshelf CRUD interactions.

The main value proposition of this project is predictable integration behavior through validation and response consistency.

Reviewer stakeholder
Reviewers validating whether the service satisfies backend contract expectations clearly and reproducibly.

Postman artefacts and focused CRUD routes indicate that external reviewability was part of the project design.

Decision Flow

How design thinking translated into decisions

The goal is to show the trace from research and insight to concrete product or system decisions, then to the outcomes those decisions supported.

Design Thinking Flow

Each step keeps the movement from evidence to action explicit before the rationale expands it.

  1. Step 1
    Contract-first framing

    Treated API quality as a request/response discipline problem before expanding features.

    Signal: Payload rules and response consistency became the core scope.
  2. Step 2
    Handler clarity

    Kept route handlers focused and aligned with CRUD responsibilities.

    Signal: The implementation remains reviewer-readable without architectural overgrowth.
  3. Step 3
    Validation support

    Paired the API with Postman artefacts to improve verification speed.

    Signal: Review confidence is supported by explicit validation assets, not only code structure.

Decision Rationale

Each decision keeps the path from insight to execution visible before ending on the outcome signal.

Strict payload rules
Insight

Small APIs still become fragile when required fields and domain consistency checks are underspecified.

Decision

Applied validation rules for payload completeness and reading-page consistency.

Outcome

The service reads as disciplined and integration-friendly despite compact scope.

Reviewer-ready artefacts
Insight

Course APIs are easier to trust when verification can happen quickly without manual guesswork.

Decision

Kept Postman collection and environment artefacts close to the project.

Outcome

The project improves reviewer confidence through a clearer validation path.

Solution and System Execution

Execution choices and delivery details

This section preserves the technical and operational substance: architecture, responsibilities, trade-offs, and implementation quality signals.

System Design

Node.js service using Hapi route definitions and in-project handlers, with nanoid for identifiers and Postman collection/environment artifacts for API review.

Source-backed Impact

Shows that API quality can come from disciplined contracts, response consistency, and reviewer-ready validation assets rather than feature count alone.

Responsibilities

  • Implemented book CRUD handlers and route registration
  • Applied payload validation rules for required fields and reading-page consistency
  • Prepared API review artifacts through Postman collection files

Stack Decisions

  • Used Hapi.js for explicit route and handler structure
  • Used nanoid for generated book identifiers
  • Kept reviewer validation close to the project through Postman artifacts

Trade-offs

  • Kept the API compact to emphasize contract clarity over feature breadth
  • Used in-project data handling appropriate for a course API baseline

Challenges

  • Maintaining consistent error and success responses across all CRUD operations
  • Supporting practical filters without expanding the API beyond the course brief
Outcomes and Proof

What was delivered and what can be verified

Outcome claims remain conservative and source-backed, while proof records and recruiter-safe links surface the strongest verification trail available.

Validation Signals

  • CRUD routes are organized through Hapi route definitions.
  • Postman collection and environment artefacts are available for reviewer validation.

Source-backed Outcomes

  • CRUD routes organized through Hapi route definitions
  • Postman collection and environment artifacts available for reviewer validation
Retrospective and Limits

What the project proves, and what it does not

Strong case studies show both what was learned and where the current evidence stops.

Retrospective

Next iteration should add automated tests and a clearer request-flow diagram before adding more endpoints.

Evidence Limits

  • Current sources do not provide automated test coverage or production deployment evidence.
  • The project should be read as compact API contract proof, not as a scaled backend platform.

Lessons

  • Payload rules should be defined early to reduce branching complexity in handlers
  • Postman artifacts can build reviewer trust quickly for small APIs