Node.js Coding and Architecture

Convert a backend change request into testable acceptance criteria and implementation steps.

Implement a pure JavaScript function from written business rules without using AI-generated code.

Determine the time and space complexity of a JavaScript solution.

Refactor a JavaScript function into single-responsibility units while preserving its behavior.

Interpret a Node.js stack trace to identify the originating failure.

Review an AI-generated code patch for correctness, edge cases, security risks, and unsupported assumptions.

Predict the execution order of synchronous code, microtasks, and timers in Node.js.

Rewrite a Promise chain using async/await without changing its behavior.

Handle rejected asynchronous operations without creating unhandled promise rejections.

Choose between sequential and concurrent execution for a set of outbound API calls.

Add timeout and cancellation behavior to an outbound HTTP request with AbortController.

Implement retries for transient API failures using exponential backoff and jitter.

Respond correctly to an external API rate limit using response metadata.

Make an integration operation idempotent when the same event is delivered more than once.

Select appropriate HTTP methods and status codes for a backend use case.

Define a REST API contract for an integration job resource.

Implement an Express route and controller that satisfy a specified API contract.

Validate and normalize an incoming JSON payload before business logic executes.

Return consistent error responses through centralized Express error handling.

Implement Express middleware that authenticates a bearer token and enforces an authorization rule.

Implement an outbound API adapter that translates a downstream response into an internal model.

Document an Express endpoint with an OpenAPI specification.

Model integration jobs, attempts, and results using relational tables, keys, and cardinalities.

Write PostgreSQL SELECT queries with filtering, ordering, and aggregation.

Retrieve related data with appropriate PostgreSQL joins.

Perform parameterized INSERT, UPDATE, and DELETE operations.

Choose database constraints and indexes for a specified access pattern.

Use a PostgreSQL transaction to preserve consistency across related writes.

Create and apply a reversible database migration.

Implement a Node.js repository that uses a connection pool to persist integration jobs.

Write a Jest unit test using arrange-act-assert structure.

Test the success and failure behavior of an asynchronous function.

Replace an outbound API dependency with a controlled Jest mock.

Test an Express endpoint through its HTTP boundary with Supertest.

Isolate PostgreSQL state between integration test cases.

Use breakpoints and variable inspection to locate a Node.js defect.

Add structured logs and a correlation ID to trace one request across service operations.

Derive a focused test strategy from the failure risks of an integration workflow.

Configure strict TypeScript compilation for a Node.js project.

Add TypeScript annotations to JavaScript values and functions without using the any type.

Model API payloads with TypeScript interfaces and type aliases.

Use union types and narrowing to handle alternative results safely.

Narrow an unknown caught error before reading its properties.

Apply types to Express request handlers, including route parameters, query values, and request bodies.

Migrate one tested JavaScript module to TypeScript while preserving its behavior.

Combine runtime payload validation with TypeScript static types.

Translate product requirements into functional and non-functional backend requirements.

Draw a sequence diagram for a request that crosses multiple systems.

Separate an Express feature into controller, service, repository, and external-adapter responsibilities.

Inject a backend dependency so that business logic can be tested in isolation.

Identify high coupling and low cohesion in a Node.js module.

Choose synchronous or asynchronous communication for a specified integration workflow.

Design queue, retry, and dead-letter behavior for failed background work.

Produce a modular-monolith architecture for the course integration service and explain its failure boundaries.

Explain how tokens, context windows, and probabilistic generation affect a Claude application.

Select a Claude model for a task using capability, latency, and cost constraints.

Configure Claude API credentials securely and send a typed Messages API request from a Node.js backend.

Handle Claude API errors, rate limits, and token-usage metadata.

Write system and user prompts with explicit constraints and examples.

Construct a context payload that includes only information relevant to the current task.

Validate structured Claude output before using it in application logic.

Implement server-side streaming for a Claude response.

Distinguish a deterministic workflow from an agentic workflow for a specified requirement.

Define a Claude tool with a precise JSON Schema input contract.

Validate and authorize a tool request before executing backend code.

Implement a bounded tool-use loop that terminates safely.

Construct a bounded task-routing agent with the Claude Agent SDK.

Explain the client, server, resource, prompt, and tool roles in the Model Context Protocol.

Expose one integration capability through a local MCP server.

Configure Claude Code project instructions and a hook that enforces a local quality check.

Create a threat model covering prompt injection, sensitive-data exposure, and unsafe tool use.

Classify and redact sensitive data before sending it to Claude or writing it to application logs.

Apply least-privilege authorization to an AI application's tools.

Implement input and output guardrails for a specified Claude feature.

Create a small evaluation dataset containing normal, edge, and adversarial cases.

Define a repeatable scoring rubric for Claude application outputs.

Use traces and failed evaluation cases to identify the source of an AI application defect.

Calculate token cost for a workload and enforce a per-request usage budget.

Build a production-oriented Docker image for a Node.js service.

Run the Node.js service and PostgreSQL together with Docker Compose.

Separate development and production configuration while keeping secrets out of images.

Create a CI workflow that installs dependencies and runs linting and tests.

Provision an Amazon RDS PostgreSQL database and apply application migrations.

Deploy a containerized Node.js API to AWS App Runner.

Implement health checks and graceful shutdown for the deployed service.

Configure centralized logs, one operational metric, and one alert for the deployed API.

Solve an array or string problem using a hash map.

Solve an array problem using the two-pointer technique.

Solve a fixed-size sliding-window problem over an array or string.

Solve a last-in-first-out or first-in-first-out problem with a stack or queue.

Demonstrate the deployed portfolio service and explain its architecture, reliability mechanisms, and engineering trade-offs.

Complete a timed CCDV-F practice exam and classify incorrect answers by blueprint domain.

Write evidence-based résumé bullets for API integration and backend project work.

Structure behavioral interview answers with the STAR framework.