USE CASE
Promotion preparation
INTERNAL GROWTH
Prepare for promotion as a body of evidence
A promotion case asks whether you have sustained the next scope of responsibility and produced verifiable results over time. It is different from a one-off external interview.
These are browsing paths through shared questions, not company level criteria. Map the evidence to your organization’s capability model and review period.
CAREER PATHIndividual-contributor promotion
Build a case around deeper craft, wider ownership, and impact beyond your own tasks.
Browse matching questions CAREER PATHTransition to or growth as a first-line managerShow how results increasingly come through team design, coaching, delegation, and operating mechanisms.
Browse matching questions CAREER PATHManager-of-managersShow durable outcomes through leaders, cross-team decisions, succession, and organizational health.
Browse matching questionsBuild the case in four parts
- Target scopeName the path and responsibilities expected next.
- Sustained outcomesShow the baseline, outcome, time span, and your attributable contribution.
- How the result was achievedExplain trade-offs, collaborators, risks, and what changed after setbacks.
- Evidence and gapsSeparate verified facts from claims, include counterevidence, and name the next gap to close.
These are the same questions found in the library, grouped here by the capability each one mainly examines.
1060 questions
Questions 1–50 of 1060 on this page.
A · Professional problem solving and implementation50
- You built a customer-support Q&A prototype. How would you design an evaluation set to decide whether it may only assist retrieval, or can reply to customers directly?
- What does an algorithm model and the features it depends on truly cost? How do you count training, inference, feature computation and storage, labeling, and maintenance, and how do you judge whether a feature is worth keeping?
- Enterprise knowledge documents may change, be withdrawn, or become restricted, yet users still receive answers citing old content. How would you propagate changes from source documents through chunks, indexes, caches, and existing citations, and prove that an update or deletion took effect?
- A new model raises overall accuracy from 91% to 94%, but errors remain concentrated in cases that affect customer rights. The team wants to ship based on the aggregate score. How would you decide?
- A RAG assistant cites an internal document, but its owner has updated the process and the new version is not indexed yet. How would you define freshness goals, propagation, and answer behavior during the gap?
- A multi-step agent reads project permissions at startup. Before step three, the user is removed from the project, but the task still holds a tool token. How would you design authorization checks and cancellation semantics?
- A user updates account settings and refreshes immediately, but a read replica returns the old value. Reading from the primary adds load, while waiting for replication may time out. How would you design the experience?
- A sign-up form ends up in inconsistent states because of duplicate submissions and weak-network retries. How would you map its states and transitions, and decide which logic to extract into its own unit?
- Implement a retry wrapper that retries by error type, supports a maximum attempt count, backoff, and cancellation, and does not overwhelm the dependency. Define the interface before coding, then explain how to make clocks, waits, and tests deterministic.
- After multiple macro and code-generation expansions, compiler errors point only to generated files, leaving users unable to find the original code. How would you design diagnostics?
- Incremental compilation is fast, but changes to a shared header sometimes fail to rebuild all dependent targets. How would you find the dependency-tracking gap?
- A compiler upgrade changes struct layout or calling conventions, but some plugins are still built against the old ABI. How would you manage compatibility and migration?
- A long-running process keeps using more memory, while object counts in heap snapshots fluctuate. How would you use evidence to distinguish a true leak, intentional cache retention, fragmentation, or growth in native memory?
- In production the same order is occasionally submitted twice, and you cannot reproduce it locally. How would you narrow it down, and would you stop the bleeding first or add observability first?
- An old system keeps accumulating new business and is becoming hard to maintain. How would you create an adapter boundary between old and new systems so legacy rules and data models do not spread into new code? Explain the migration steps and any compromises or risks you would accept.
- Tell me about an architecture upgrade. Why did it have to be upgraded rather than patched further, what challenges came up during migration, how did you keep the business running, and did the benefit materialize?
- For a given capability, how do you decide between building it, adopting open source, or buying it? How do building and open source differ in cost, control, maintenance, and risk, and when should you switch from one to the other?
- A repository accepts external contributions, and CI runs build scripts, reuses caches, reads test credentials, and produces release artifacts. How would you separate untrusted execution, credential permissions, and cache boundaries so code cannot read secrets or poison trusted artifacts?
- A long-lived credential is shared by several services. Security requires prompt rotation, but all dependents cannot be stopped at once. How would you proceed?
- How do you identify and record technical debt and pay it down without stopping business delivery? Which debts are worth paying and which can be left for good, and how do you judge?
- Your solution depends on a lower-level service or library. If it changes substantially, how would you migrate, fall back to a version that preserves core features, or replace it?
- In the technical area you work in, how is the industry developing? Is your solution adapting to that trend or going against it?
- The application can be rolled back, but a database migration removed an old field and the previous version can no longer start. How would you redesign release order and rollback?
- What technical gains did this project bring? How do you measure them, and what complexity and maintenance cost did you pay for them?
- You take over a module that is about to ship and has very low test coverage, and time is short. How do you decide which tests to add first, and how do you explain that order to the team?
- The framework allows concurrent background UI updates, but a slow response occasionally overwrites a newer selection. How would you design concurrent state updates?
- A complex form has field validation, cross-field rules, and server errors that overwrite one another during edits. How would you divide framework state from business state?
- Several pages share server data and framework caching reduces requests, but stale results appear after users switch accounts. How would you design cache keys and invalidation boundaries?
- After a frontend framework upgrade, compilation succeeds, but render timing, default caching, or side-effect order changes. How would you verify product behavior remains correct?
- A user signs in within one child app but loses permissions or session state when switching to another. How would you design the boundary for shared auth context?
- One app emits an “order completed” event, but other modules interpret it differently, causing duplicate requests and divergent page state. How would you define a cross-app event contract?
- Users report a blank page after navigating across apps, while each team’s monitoring appears healthy. How would you establish end-to-end observability?
- After independently developed apps are integrated, styles collide, themes differ, and overlays are clipped. How would you choose a style-isolation strategy?
- Several frontend modules build independently, but releases still require coordination. What evidence would show they have a real independent delivery boundary?
- A large frontend makes parallel delivery difficult, but splitting it into several apps at once is risky. How would you plan an incremental migration and judge each step?
- If a micro-app fails at startup, users cannot access other modules. How would you isolate the failure and, if needed, disable noncritical features to keep the rest available?
- Several child apps depend on different React and component-library versions, causing both duplicate downloads and runtime conflicts. How would you govern shared dependencies?
- Several child apps share the browser address bar, but back/forward, deep links, and login redirects behave inconsistently. How would you define a routing contract?
- Two services write directly to the same business table, and an immediate shutdown is impossible. How would you gradually establish a single data owner?
- An order is updated successfully, but a cross-service report reflects it minutes later. The product asks for “real-time status.” How would you define and implement consistency expectations?
- A cross-service flow includes payment, inventory reservation, and shipment. How would you define compensations and irreversible boundaries when later steps fail?
- Incidents recur at service boundaries. Each team can show its service is healthy, but nobody owns end-to-end recovery. How would you repair accountability?
- Several services have separate owning teams, yet a small change often requires three or four teams to release together. How would you assess whether the service boundaries have failed?
- A new feature adds startup dependencies and cold start becomes much slower on low-end devices, while high-end metrics remain normal. How would you prioritize optimization?
- After code changes, the build system sometimes misses affected apps and sometimes rebuilds the entire repository. How would you validate the dependency graph and cache invalidation rules?
- One repository contains multiple teams and production deployment config, but code-owner rules do not cover temporary admins and automation accounts. How would you review permission and approval boundaries?
- Two product packages form a dependency cycle, and splitting them creates a need to share domain types. How would you change the boundaries without hiding the cycle in a new shared package?
- A team decides to split a large repository, but history, CI, package releases, and ownership are connected. How would you sequence the migration?
- In a monorepo, shared packages are casually changed by one team, while consumers discover behavior changes only after upgrading. How would you establish ownership and compatibility contracts?
- Packages have very different release cadences, but shared version numbers force unrelated teams to release together. How would you design versioning and release policy?
No questions in this section match your target. ·