Modern JavaScript Software Engineering

Initialize a Node.js project and manage dependencies and scripts with npm and package.json.

Split a small program into ES modules using named imports and exports.

Specify a function contract by listing its accepted inputs, returned output, side effects, and failure behavior.

Decompose a small feature into state, transformations, external boundaries, and failure cases before writing code.

Identify an implementation decision that should be hidden behind a stable module interface and refactor the code to create that boundary.

Create a feature branch, make focused Git commits with clear messages, and review its diff before merging.

Use an error message and stack trace to locate the source of a failure.

Trace an AI-generated function with normal and edge-case inputs and accept, revise, or reject it against its stated contract.

Trace the execution order of synchronous code, promise callbacks, and timers using the event-loop model.

Consume a promise with then, catch, and finally while preserving error propagation.

Rewrite a promise chain with async and await without changing its behavior.

Handle failures in an async function with try, catch, and meaningful error propagation.

Run independent asynchronous operations concurrently with Promise.all and explain when not to do so.

Cancel or time out an external request with AbortController.

Read and write structured JSON data using the promise-based Node.js file-system API.

Load configuration from environment variables and fail clearly when required values are missing.

Determine the Big-O time and space complexity of basic loops and common array operations.

Derive normal, boundary, and invalid test cases from a small coding-problem statement.

Solve an array or string problem using a single linear scan.

Choose and use a Map or Set for keyed lookup, frequency counting, or duplicate tracking, and explain the choice.

Solve a sorted-array problem with the two-pointer technique.

Use a stack to validate balanced delimiters in a string.

Implement a recursive depth-first traversal of a small tree by defining its base case and recursive step.

Implement binary search over a sorted array and state its loop invariant.

Identify the method, path, headers, body, and status code in an HTTP request-response exchange.

Create an Express application with a health-check route and an npm start script.

Implement list and detail GET routes for an in-memory ticket resource.

Implement a POST route that creates a ticket and returns an appropriate status and representation.

Implement PATCH and DELETE routes with correct not-found behavior.

Implement reusable request middleware and centralized error-handling middleware, then trace their execution order.

Validate incoming JSON and route validation failures through the centralized handler to produce consistent client-error responses.

Add allowlisted filtering, sorting, and pagination to a ticket-list endpoint.

Translate support-ticket requirements into MongoDB collections and document shapes.

Connect a Node.js application to MongoDB with Mongoose using environment-based configuration.

Define a Mongoose ticket schema with required fields, defaults, enums, and timestamps.

Create and retrieve ticket documents through a Mongoose model.

Update and delete ticket documents while handling missing records.

Implement filtered, sorted, and paginated MongoDB queries for ticket searches.

Represent and retrieve the relationship between users and their tickets using document references.

Choose an index for a frequent ticket query and explain its read-versus-write trade-off.

Turn a behavioral requirement into happy-path, boundary, and failure test cases.

Reproduce a logical bug, form a hypothesis from the available evidence, and test it using breakpoints and variable inspection.

Write deterministic unit tests for a synchronous JavaScript function using Node's test runner.

Test fulfilled and rejected outcomes of an asynchronous function.

Write HTTP integration tests for an Express route using Supertest.

Isolate MongoDB integration tests so that one test cannot contaminate another.

Replace an external dependency with a controllable test double at a clear module boundary.

Refactor tested code in small steps and use the test suite to detect behavior changes.

Create a basic API threat model by identifying assets, trust boundaries, likely abuse cases, and matching controls.

Store and verify user passwords with a modern password-hashing library instead of plaintext.

Issue and verify signed authentication tokens for protected API routes.

Enforce customer and support-agent permissions with authorization middleware.

Reject malformed, oversized, or MongoDB operator-injection payloads with allowlisted schema validation.

Configure explicit CORS rules and standard HTTP security headers for an Express API.

Apply rate limits to authentication and AI-assisted endpoints.

Keep secrets and personal data out of source control, client errors, and application logs.

Explain how model instructions, user input, context, output tokens, and model limitations affect an LLM response.

Run the application without API credit by substituting a deterministic mock Claude client.

Send a minimal request to the Anthropic Claude API from Node.js using an environment-provided API key.

Use system and user messages to separate stable application rules from ticket content.

Request structured JSON from Claude and validate the returned structure before using it.

Read token-usage metadata and estimate the cost of a small batch of requests.

Handle Claude API timeouts, rate limits, and transient failures with bounded retries and backoff.

Treat ticket text as untrusted data and resist prompt-injection attempts that conflict with application rules.

Produce a validated triage object containing an allowlisted category, priority, and concise summary faithful to the ticket.

Draft a response grounded only in supplied support-policy text.

Detect missing or conflicting context and route the ticket for human review instead of guessing.

Redact selected personal data from ticket text before sending it to an external model.

Store an AI suggestion with its model, prompt version, timestamp, and human-approval status.

Implement an Express endpoint that invokes the AI-assistant service and returns a validated suggestion.

Write an integration test for an AI-assisted endpoint using a mocked Claude response.

Evaluate a prompt against a fixed ticket set and record classification errors and unsafe responses.

Audit the support-ticket assistant against its functional requirements and define measurable operational constraints for production.

Draw and annotate a component and data-flow diagram that identifies synchronous request paths and operations better moved to background processing.

Attach unique request identifiers to incoming Express requests and emit structured JSON logs without exposing sensitive data.

Upgrade the basic health route into separate liveness and database-readiness checks.

Handle process termination signals with graceful server shutdown and database disconnection.

Configure continuous integration to run linting and automated tests for each proposed code change.

Deploy the Node.js service with separate development and production configuration.

Explain how stateless servers, database capacity, model rate limits, latency, and cost constrain scaling.

Solve a timed array or hash-map interview problem while explaining the approach and complexity aloud.

Solve a timed two-pointer problem and verify it with boundary cases.

Review an unfamiliar AI-generated solution to identify a correctness bug and an avoidable complexity cost.

Explain promises, async and await, event-loop ordering, and asynchronous error handling in interview-style questions.

Lead a small system-design discussion for the support-ticket assistant from requirements through trade-offs.

Write a project README that enables another developer to configure, test, and run the application.

Deliver a five-minute project walkthrough covering architecture, security, testing, AI safeguards, and personal contributions.

Write evidence-based résumé bullets that describe the project's engineering decisions and measurable behavior.