Junior Backend Software Development

Predict the execution order of a Node.js program containing promises, timers, and `process.nextTick`.

Choose an appropriate promise-concurrency pattern for independent, dependent, and partially fault-tolerant operations.

Propagate an asynchronous failure through an Express request without creating an unhandled rejection.

Measure and identify an event-loop-blocking operation in a Node.js endpoint.

Stream a large file through an HTTP response while respecting backpressure.

Implement graceful shutdown that stops new requests and closes active resources safely.

Refactor one Express resource into separate route, controller, service, and repository layers.

Separate Express application construction from server startup so the application can be tested independently.

Inject a repository dependency into a service without coupling business logic to Mongoose.

Validate required environment variables when the application starts.

Implement centralized error handling with distinct operational error types.

Add structured request logging with a correlation ID.

Introduce API versioning without duplicating shared business logic.

Model a business requirement as REST resources with appropriate HTTP methods and status codes.

Define a consistent JSON error-response contract for client and server failures.

Validate and normalize request parameters, bodies, and query strings before they reach business logic.

Implement bounded pagination with filtering and an allowlist of sortable fields.

Implement an idempotency key for an order-creation endpoint.

Validate a multipart image upload by file type and size before storage.

Document one API resource with an OpenAPI specification.

Verify an endpoint's HTTP contract using an API client.

Choose between embedding and referencing for a stated MongoDB access pattern.

Create a compound index that supports a specified filter and sort query.

Use MongoDB query-execution statistics to identify an inefficient query.

Build an aggregation pipeline that joins, groups, and summarizes related business data.

Use a MongoDB transaction for a multi-document state change.

Prevent a race condition by replacing a read-modify-write sequence with an atomic update.

Implement cursor-based pagination with a stable ordering key.

Write a repeatable data-migration script for a Mongoose schema change.

Store and verify user passwords using an appropriate adaptive password hash.

Issue short-lived access tokens and rotate refresh tokens securely.

Revoke a compromised refresh-token session without invalidating every user session.

Enforce role- and resource-based authorization in an Express endpoint.

Configure cookies, CORS, and CSRF protection for a stated browser authentication flow.

Block NoSQL injection and unsafe property assignment at the API boundary.

Apply security headers and endpoint-specific rate limits to an Express application.

Create a concise threat model for a sensitive backend workflow.

Write a unit test for service-layer business logic using an injected test double.

Write an integration test that exercises an Express endpoint against an isolated test database.

Reset database state so integration tests remain independent and repeatable.

Test authentication and authorization failures for a protected resource.

Replace an external service with a controllable mock in an automated test.

Test validation, duplicate requests, and downstream-failure edge cases.

Interpret a coverage report to find an untested behavior rather than merely an uncovered line.

Run linting and automated tests as required checks for a proposed code change.

Measure endpoint latency and throughput under a controlled load.

Locate a backend bottleneck using timing data rather than guesswork.

Select a cache key and expiration policy for a read-heavy endpoint.

Implement and verify Redis caching for a read-heavy endpoint.

Invalidate cached data after a related write operation.

Move a non-critical slow task from the request path into a background job.

Make a background job safe to retry without duplicating its business effect.

Add liveness and readiness endpoints that reflect application dependencies.

Divide a backend change into focused commits with informative messages.

Use a feature branch to prepare a pull request without altering the main branch.

Resolve a merge conflict while preserving the intent of both changes.

Review a backend pull request for correctness, security, and test coverage.

Convert a feature request into small implementation issues with acceptance criteria.

Use Git history to identify the change that introduced a regression.

Create a production-oriented multi-stage Dockerfile for a Node.js API.

Use Docker Compose to run an API with MongoDB and Redis locally.

Keep environment-specific configuration and secrets outside a container image.

Configure a continuous-integration workflow to install, lint, and test the backend.

Deploy a containerized Node.js API to a managed hosting environment.

Configure HTTPS and trusted proxy behavior for a deployed Express application.

Create and verify a MongoDB backup and restoration procedure.

Perform a rollback after a deliberately faulty deployment.

Write acceptance criteria for one production-grade extension to an existing MERN backend.

Draw a request-and-data-flow diagram for the selected extension.

Define the schemas, indexes, and API contract required by the extension.

Implement the extension's core business rule in a service layer.

Protect the extension with request validation, authentication, and authorization.

Add integration tests for the extension's successful and failing paths.

Profile one extension endpoint and correct a measured performance issue.

Write setup, architecture, API, testing, and deployment instructions for the upgraded project.

Explain the Node.js event loop by tracing a short asynchronous program.

Explain how an HTTP request passes through middleware, routing, business logic, and persistence.

Justify a MongoDB schema and index design using stated query patterns.

Solve a time-complexity problem using arrays, sets, or maps in JavaScript.

Diagnose a failing API endpoint from its code, logs, and HTTP response.

Review a short backend code sample and identify one correctness issue and one security issue.

Present a five-minute technical walkthrough of a portfolio backend and its trade-offs.

Write evidence-based résumé bullets and an interview story from a completed backend feature.