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.

Create a Git repository and produce focused commits that clearly describe working changes.

Develop a change on a Git branch and resolve a simple merge conflict.

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

Use breakpoints and variable inspection to diagnose a logical bug in Node.js code.

Refactor a long function into clearly named units while preserving its observable behavior.

Verify AI-generated code against stated requirements, assumptions, edge cases, and security concerns before accepting it.

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.

Use a Map to implement frequency counting or constant-time lookup.

Use a Set to detect duplicates or track previously seen values.

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

Use a stack to validate balanced delimiters in a string.

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.

Create reusable Express middleware and predict its execution order.

Validate incoming JSON and return a consistent client-error response for invalid data.

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.

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.

Use a coverage report to find meaningful untested behavior rather than merely increasing a percentage.

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

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 or oversized request payloads with schema-based validation.

Prevent MongoDB operator injection by allowlisting accepted query fields and values.

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.

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.

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

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

Classify a support ticket into an allowlisted category and priority using validated structured output.

Generate a concise ticket summary that preserves the customer's stated facts.

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.

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.

Convert the support-ticket assistant's user needs into functional requirements and measurable operational constraints.

Draw a component and data-flow diagram for the Express, MongoDB, and Claude-based application.

Identify synchronous and background-processing boundaries for slow AI operations.

Make repeated ticket-processing requests idempotent so they do not create duplicate AI suggestions.

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.

Implement health checks, graceful shutdown, structured logging, and request identifiers for diagnosis.

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 or stack 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.