SDE-2 Backend Engineering

State the core invariants and failure guarantees of a resilient event-delivery platform.

Enable TypeScript strict mode in a Node.js service and resolve the resulting type errors without using `any`.

Validate untyped external input by combining `unknown` with custom type guards.

Represent fallible domain operations with discriminated unions and enforce exhaustive handling.

Write a generic TypeScript utility that preserves type inference across domain objects.

Organize a Node.js service into transport, application, domain, and infrastructure boundaries.

Validate environment configuration at application startup and fail with actionable errors.

Solve an array or string problem using a frequency map in O(n) time.

Design REST resources and HTTP status codes for event ingestion and delivery inspection.

Document request and response schemas, authentication, errors, and idempotency semantics in an OpenAPI specification.

Reject malformed API requests with schema validation at the transport boundary.

Return a consistent error envelope without exposing sensitive implementation details.

Enforce tenant-scoped access on requests authenticated with hashed API keys.

Write API contract tests that detect response-schema regressions.

Solve a variable-size sliding-window problem in O(n) time.

Solve a monotonic-stack problem in O(n) time.

Create a versioned PostgreSQL migration for a normalized schema containing events, delivery attempts, endpoints, and audit records.

Enforce event-delivery invariants with PostgreSQL keys, constraints, and uniqueness rules.

Select an appropriate PostgreSQL transaction isolation level for a stated race condition.

Diagnose a slow PostgreSQL query with `EXPLAIN ANALYZE`.

Create an index that matches a query's filters, ordering, and selectivity.

Implement stable keyset pagination for a delivery-history endpoint.

Configure a Node.js PostgreSQL connection pool for bounded concurrency.

Implement idempotent event ingestion with a transaction and a uniqueness constraint.

Choose a Redis data type and key design by evaluating access patterns, TTLs, cardinality, memory overhead, and Redis size limits.

Predict how Redis expiration and eviction policies affect application correctness.

Apply cache-aside caching without serving stale tenant-authorization data.

Implement an atomic sliding-window rate limiter with Redis.

Distinguish at-most-once and at-least-once message delivery under worker failure.

Configure an SQS visibility timeout and dead-letter redrive policy from processing-time and retry assumptions.

Process an at-least-once message without duplicating a delivery side effect.

Solve a binary-tree traversal problem iteratively.

Represent webhook delivery attempts as an explicit state machine with valid transitions.

Harden an outbound HTTP client against server-side request forgery and unbounded connection, response, or total wait times.

Calculate exponential-backoff retry times with bounded jitter and map them to delayed job scheduling.

Enforce per-endpoint concurrency limits while preserving required message ordering.

Use the transactional outbox pattern to avoid a database-to-queue dual-write failure.

Sign an outbound webhook with a timestamped HMAC and reject invalid or replayed signatures at the receiver.

Replay a failed delivery without erasing its original audit history.

Solve a top-k problem using a heap with O(n log k) time complexity.

Trace how Node.js schedules timers, promises, I/O callbacks, and synchronous work on the event loop.

Detect event-loop blocking with runtime delay measurements.

Decide when a CPU-bound task belongs in a worker thread rather than the main Node.js process.

Capture and interpret a Node.js heap snapshot for a suspected memory leak.

Predict the process launched by Docker combinations of `ENTRYPOINT` and `CMD`.

Use exec-form container commands so the application receives operating-system signals correctly.

Implement graceful shutdown that drains HTTP requests and stops accepting queue work.

Build a multi-stage, non-root Docker image with a minimal production filesystem.

Emit structured logs with correlation identifiers across API, queue, and delivery boundaries.

Define request-rate, error-rate, latency, queue-depth, and delivery-success metrics for the platform.

Trace an event from ingestion to outbound delivery with OpenTelemetry context propagation.

Derive a service-level objective and error-budget policy from a stated reliability target.

Run a controlled load test and interpret throughput plus p50, p95, and p99 latency.

Analyze a CPU flame graph collected during load testing to locate a Node.js performance bottleneck.

Define a symptom-based alert and an actionable runbook for delivery failures.

Solve a graph traversal problem in Java using breadth-first or depth-first search.

Translate a product prompt into functional requirements, non-functional requirements, and explicit constraints.

Estimate request volume, queue throughput, storage growth, and network usage from traffic assumptions.

Choose a synchronous or asynchronous interaction boundary based on latency and failure requirements.

Evaluate consistency and availability trade-offs during a network partition.

Select a partition key that balances load while preserving required query patterns.

Apply backpressure and load shedding to protect a saturated dependency.

Choose between a distributed lock, database constraint, and idempotency key for a coordination problem.

Solve a backtracking problem by defining choices, constraints, and termination conditions.

Model an event-delivery domain in Java using records, interfaces, and explicit null handling.

Select Java collection and concurrency primitives that make shared worker state race-safe.

Interpret JVM heap, garbage-collection, and thread-pool metrics to diagnose a stated latency or memory problem.

Implement a validated Spring Boot REST endpoint with constructor-injected dependencies and centralized error mapping.

Persist a delivery record transactionally with Spring Data JPA.

Implement an SQS-consuming Spring Boot worker with explicit concurrency, acknowledgement, and idempotency behaviour.

Write a Spring Boot integration test against a disposable PostgreSQL instance with Testcontainers.

Solve a one-dimensional dynamic-programming problem in Java from its recurrence relation.

Draw an AWS network boundary using public and private subnets, routing, security groups, and an Application Load Balancer.

Create least-privilege IAM roles for an application that accesses SQS, secrets, and operational telemetry.

Define an ECS Fargate service and Application Load Balancer with Terraform.

Define private RDS, ElastiCache, and SQS dependencies with Terraform.

Inject secrets and environment-specific configuration without storing credentials in an image.

Write a CI workflow that executes automated tests and publishes a versioned container image to Amazon ECR.

Configure a CD workflow that deploys to ECS Fargate, verifies health checks, and rolls back a failed release.

Verify that a PostgreSQL backup can restore the application's required records.

Create a threat model for event ingestion, outbound delivery, tenant data, and operator access.

Choose React Server Component and Client Component boundaries for an operational Next.js dashboard.

Apply Next.js data caching and revalidation rules to delivery-status views.

Enforce authenticated, role-scoped access to operational dashboard routes.

Protect the state-changing replay flow against cross-site request forgery and prevent untrusted delivery data from causing cross-site scripting.

Stream live delivery-status updates to the browser with Server-Sent Events.

Implement the dashboard interaction for inspecting a failed delivery and triggering a replay request.

Write a browser-level test for a failed-delivery investigation and replay flow.

Run a controlled dependency-failure drill and verify the platform's retry and degradation behaviour.

Diagnose a simulated production incident using correlated logs, metrics, and traces.

Write a blameless incident postmortem with corrective and preventive actions.

Defend the capstone architecture through requirements, estimates, bottlenecks, and trade-offs.

Complete a time-boxed backend system-design exercise using a repeatable framework.

Solve a mixed-pattern medium coding problem within a stated time limit.

Prepare evidence-based STAR stories about ownership, conflict, failure, delivery, and technical decisions.

Rewrite project and work-experience descriptions as measurable SDE-2 résumé evidence.