Senior Software Engineer

Analyze the time and space complexity of a TypeScript solution using Big-O notation.

Select arrays, sets, or maps for a problem based on required operation costs.

Solve a frequency-counting problem with a hash map.

Implement and manipulate a singly linked list in TypeScript.

Use a stack to solve a delimiter or expression-validation problem.

Use a queue to implement breadth-first traversal of a binary tree.

Implement depth-first traversal of a binary tree recursively and iteratively.

Use a heap to maintain the top k elements of a changing collection.

Select HTTP methods and status codes that preserve safety, idempotency, and cache semantics.

Design resource-oriented endpoints for a multi-tenant project-management capstone.

Validate and transform request data at an API boundary with a schema library.

Map domain and infrastructure failures to a consistent API error format.

Implement deterministic cursor pagination for a filtered and sorted collection.

Document an API operation with OpenAPI and verify the generated contract.

Define a repository interface that isolates application logic from storage technology.

Assemble one vertical API slice through routing and application logic against an in-memory repository.

Translate capstone requirements into a normalized relational schema with appropriate keys and constraints.

Write a reversible database migration with explicit up and down schema transformations.

Write SQL joins and aggregations for a multi-table reporting query.

Implement the existing repository interface with pooled, parameterized PostgreSQL queries.

Use a transaction to preserve an invariant across multiple database writes.

Choose an appropriate transaction isolation level for a stated concurrency scenario.

Select an index for a query by interpreting PostgreSQL EXPLAIN output.

Detect and eliminate an N+1 query introduced by an ORM or query builder.

Create a threat model that identifies assets, actors, trust boundaries, and likely attack paths.

Store and verify passwords using an appropriate password-hashing algorithm and parameters.

Implement secure cookie-based authentication with session rotation and expiration.

Protect a cookie-authenticated state-changing endpoint against cross-site request forgery.

Validate an OpenID Connect identity token before establishing an application session.

Enforce role-based permissions and tenant isolation at both service and data-access boundaries.

Implement rate limits for authentication and one high-cost endpoint with a defined client response.

Configure credentialed CORS for trusted origins without treating CORS as an authorization mechanism.

Refactor tightly coupled backend code so dependencies can be substituted in tests.

Write focused unit tests for application logic using controlled test doubles.

Create a deterministic database-seeding script for an isolated integration-test environment.

Write an integration test that exercises a Node.js endpoint against PostgreSQL.

Test an API's success and failure responses against its documented contract.

Write an end-to-end test for a critical React-to-API user journey.

Test timeout, retry, and unavailable-dependency behavior without flaky delays.

Construct a risk-based test strategy for the capstone and justify what not to automate.

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

Solve a contiguous-subarray problem with a sliding window.

Apply binary search to a monotonic answer space.

Merge and query overlapping intervals.

Model a graph with adjacency lists and traverse it without revisiting nodes.

Use backtracking to generate constrained combinations or permutations.

Derive a one-dimensional dynamic-programming recurrence and implement it iteratively.

Complete a timed coding interview while communicating assumptions, complexity, tests, and tradeoffs.

Generate or derive TypeScript client types from an OpenAPI contract.

Integrate the capstone's cookie-based session flow without exposing credentials to browser JavaScript.

Configure server-state caching with explicit freshness and invalidation rules.

Implement a client error policy that distinguishes validation, authorization, retryable, and render failures.

Implement an optimistic mutation with rollback after a rejected server response.

Prevent lost updates by using an API version or optimistic-concurrency token.

Implement a server-sent event update from Node.js to React with reconnect handling.

Measure a React interaction bottleneck and apply a targeted rendering optimization.

Choose between a modular monolith and separate services for a stated product scenario.

Run a load test and interpret throughput, error rate, and percentile latency results.

Apply deadlines, bounded retries, exponential backoff, and jitter to an outbound request.

Use an idempotency key to prevent duplicate processing of a retried command.

Implement a background job with explicit retry and dead-letter behavior.

Implement a cache-aside read path with a defined invalidation rule.

Build an idempotent event consumer under at-least-once message delivery.

Use the transactional outbox pattern to coordinate a database update with event publication.

Build a minimal, non-root, multi-stage Docker image for the Node.js service.

Configure a Docker Compose environment with networking, persistent storage, and health checks for the application and PostgreSQL.

Create a CI pipeline that runs static checks, tests, and image builds on each change.

Configure least-privilege task permissions, secret retrieval, and network access for application-to-database connectivity.

Deploy the containerized service to Amazon ECS Fargate and connect it to PostgreSQL on Amazon RDS.

Define deployment health criteria and execute a rollback after a failed release.

Add structured logs with request correlation across frontend and backend operations.

Instrument one request path with latency metrics and a distributed trace.

Turn an ambiguous product prompt into functional requirements and explicit quality constraints.

Estimate traffic, storage, and bandwidth from stated usage assumptions.

Define service APIs and a data model for a system-design prompt.

Choose between relational, document, key-value, and object storage for stated access and consistency requirements.

Place caches and a CDN in a read-heavy architecture and define invalidation behavior.

Design an asynchronous workflow with queues, retries, idempotency, and failure handling.

Identify scalability bottlenecks and single points of failure in an architecture diagram.

Present an end-to-end design for a collaborative full-stack application and defend its tradeoffs.

Create an as-built capstone architecture diagram and identify the gaps between its current and production-ready states.

Record one significant capstone tradeoff in an architecture decision record.

Write operational documentation for local setup, deployment, migration, and rollback.

Demonstrate the capstone through a concise scenario that exposes its full-stack and reliability features.

Convert project contributions into résumé bullets that state scope, action, and measurable effect.

Prepare STAR narratives for ownership, conflict, failure, ambiguity, and technical leadership.

Conduct a timed system-design mock interview and identify concrete improvements from the result.

Create a targeted application and interview-practice plan for FAANG and large Polish product companies.