Senior Staff Engineer Job Transition

Calculate latency, throughput, concurrency, storage, and bandwidth estimates from stated workload assumptions.

Explain how network latency and partial failure affect communication between services.

Compare vertical scaling, horizontal scaling, and load distribution for a specified workload.

Choose an availability target and calculate its permitted downtime.

Distinguish strong, eventual, causal, and read-your-writes consistency using concrete scenarios.

Apply the CAP trade-off to a specified network-partition scenario without treating it as a general design rule.

Choose between synchronous and asynchronous communication for a given interaction.

Draw a failure-aware request flow that includes deadlines, retries, duplicate requests, and degraded behavior.

Identify cohesive business capabilities from a domain narrative.

Propose service boundaries using data ownership, rate of change, and team-coupling criteria.

Compare a modular monolith with microservices for a specified organizational and operational context.

Detect chatty communication and inappropriate coupling in a service decomposition.

Design a resource-oriented REST API for one case-study capability.

Specify API errors, pagination, filtering, idempotency, and versioning behavior.

Model a multi-service interaction with a sequence diagram.

Evaluate an API and service-boundary proposal against its stated architecture drivers.

Select PostgreSQL, a key-value store, or a document store for a stated access pattern.

Design a relational schema that enforces the invariants of one case-study capability.

Choose indexes by interpreting query patterns and execution-plan evidence.

Compare replication and partitioning strategies for a stated scale and availability requirement.

Define explicit data ownership and access rules across service boundaries.

Choose between a local transaction, distributed coordination, and a saga for a business operation.

Design an idempotent transactional-outbox flow for reliable event publication.

Plan a backward-compatible database schema migration with rollback and verification steps.

Distinguish commands, events, and queries in an integration design.

Define an event schema with stable semantics and compatibility rules.

Choose a topic and partition key for required ordering and scalability.

Explain at-most-once, at-least-once, and effectively-once processing guarantees.

Implement a Spring Boot event producer using a transactional-outbox boundary.

Implement an idempotent Spring Boot event consumer.

Design retry, dead-letter, replay, and poison-message handling for a consumer.

Test an asynchronous workflow for duplicates, reordering, delay, and dependency failure.

Define user-centered service-level indicators and objectives for one critical journey.

Use an error budget to decide whether to prioritize features or reliability work.

Create a failure-mode analysis for a distributed request path.

Configure timeout, retry, exponential-backoff, and jitter policies for a specified dependency.

Select circuit-breaker, bulkhead, load-shedding, or graceful-degradation behavior for a failure scenario.

Design correlated logs, metrics, and traces for diagnosing one cross-service transaction.

Create an actionable dashboard and symptom-based alert for a service-level objective.

Write a concise incident runbook and conduct a blameless incident-review exercise.

Map compute, storage, networking, messaging, and identity requirements to suitable cloud service categories.

Create a production-oriented container image for a Spring Boot service.

Define Kubernetes deployment, service, health-check, resource, and autoscaling settings for that service.

Separate application configuration from secrets and define secure rotation behavior.

Design a CI pipeline with fast feedback, repeatable builds, and enforceable quality checks.

Design a progressive delivery and rollback strategy for a backward-compatible release.

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

Specify authentication, authorization, transport protection, and audit controls for one service interaction.

Create characterization tests around risky behavior in a legacy Spring Boot component.

Refactor a Spring Boot service to improve cohesion and coupling while preserving observable behavior.

Identify architecture smells from dependency, deployment, ownership, and change-coupling evidence.

Define an architecture fitness function for one important system constraint.

Choose between incremental refactoring, strangler migration, replatforming, and replacement for a legacy scenario.

Decompose a modernization initiative into reversible migration steps.

Plan compatibility across API, event, and database changes during a rolling migration.

Define technical-health measures that reveal delivery friction, reliability risk, and architectural decay.

Write an architecture decision record that captures context, options, decision, and consequences.

Write a concise request-for-comments document for a cross-team technical change.

Evaluate competing technical options with a weighted trade-off matrix and sensitivity check.

Construct a dependency-aware technical roadmap tied to measurable business outcomes.

Define ownership and decision rights for a cross-team architecture initiative.

Facilitate an architecture review that separates constraints, facts, assumptions, and preferences.

Resolve a simulated technical disagreement using inquiry, evidence, and an explicit decision mechanism.

Create a mentoring plan that delegates a meaningful technical decision while preserving appropriate support.

Conduct a structured discovery conversation that uncovers goals, constraints, risks, and hidden assumptions.

Map stakeholder interests, influence, concerns, and required communication for an initiative.

Reframe a requested solution as underlying outcomes and testable hypotheses.

Explain a technical trade-off in business terms involving cost, risk, speed, and reversibility.

Present an architecture recommendation using a claim-evidence-consequence structure.

Respond constructively to skeptical stakeholder questions without overstating certainty.

Negotiate a phased scope that protects essential quality attributes under a delivery constraint.

Write an executive architecture summary with a recommendation, alternatives, risks, and requested decision.

Produce a prioritized requirements and quality-attribute brief for the case-study platform.

Create defensible workload, capacity, and growth estimates for the platform.

Produce context, container, and critical-component diagrams with clearly defined responsibilities.

Specify the platform's service contracts, data ownership, and event contracts.

Defend the platform's consistency, transaction, caching, and failure-handling choices.

Define the platform's deployment, security, observability, and recovery approach.

Record the platform's highest-impact decisions and unresolved risks in architecture decision records.

Deliver a timed architecture review and revise the design in response to evidence-based feedback.

Analyze the time and space complexity of a Java solution and identify its dominant bottleneck.

Solve a timed Java collections problem using an appropriate hash-based or pointer-based pattern.

Solve a timed tree or graph traversal problem and explain the chosen traversal strategy.

Implement a small Spring Boot feature with clear boundaries and focused automated tests.

Refactor an unfamiliar Java service while preserving behavior and explaining each design decision.

Lead a mock system-design interview from requirement discovery through trade-off evaluation.

Construct six concise evidence stories covering ambiguity, influence, failure, conflict, delivery, and technical judgment.

Tailor a résumé and project-evidence portfolio to the Staff/Principal expectations of a target employer.