TOPIC
Engineering systems
These are the same questions found in the library, grouped here by the capability each one mainly examines.
97 questions
Questions 1–50 of 97 on this page.
A · Professional problem solving and implementation45
- After a foundation-model change, the average score improves, but outcomes worsen for a few important customers. How would you decide whether to ship, stage, or roll back?
- You ask an AI to review a configuration or generate a piece of code. How do you decide whether it can go live?
- 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?
- Production answers contain incorrect citations or degrade in quality, but prompts and retrieval context may include sensitive data and cannot be logged by default. What telemetry would help distinguish retrieval, model, and tool failures while controlling data exposure?
- A very large CSV must be validated without loading the whole file into memory. On malformed rows, the tool should report line numbers and continue checking. How would you design the parser interface?
- 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?
- After splitting a large frontend bundle into several smaller ones, the first screen got slower. What causes would you suspect, and how would you verify them?
- 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?
- Some production resources differ from their declared configuration, including undocumented emergency fixes. How would you distinguish intentional changes from unexplained differences, assess the risk of overwriting state, restore trust, and prevent recurrence?
- After a release goes wrong, the team says “we can roll back.” How would you check that this is true and not just a line in the plan?
- A company’s frontend projects live in separate repositories, and someone proposes merging them into a monorepo. How would you decide whether to do it, and how would you validate it in steps?
- 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?
- 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?
- 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?
- The repository has hundreds of packages and full CI is slow. The team wants to test only “affected” areas. How would you prove selective testing does not miss critical dependencies?
- A core flow passes mouse testing, but keyboard or screen-reader users cannot complete it. How would you include accessibility in release gates?
- A critical user journey across several pages and services regresses often. How would you define the scope and priority of automated tests?
- A widely used dependency is disclosed as critically vulnerable, but upgrading may introduce compatibility issues. How would you sequence the response?
- From an engineering view, how do you estimate the overall cost of a system? How are storage and compute costs each calculated, and which grow linearly with scale and which do not?
- When the business operates across several countries and regions and user data must flow across borders, how do you solve data compliance in systems and processes, and how do you judge and decide in gray areas where the rules are unclear?
- Tell me about a project you worked on. Why did you choose that technical approach over the others, how was the decision made, and what were its pros and cons?
No questions in this section match your target. ·
B · Business understanding and domain modeling5
- A producer plans to rename a field and change an enum’s meaning, while a dozen teams depend on the current schema. How would you manage the change?
- Mobile events may arrive days late, while reports must reflect event time. How would you model and process late, corrected, and duplicate events?
- Customer master data has separate identifiers and states in CRM, billing, and product systems, so downstream reports disagree. How would you establish explainable sources of truth?
- A support ticket can be reopened when a customer provides new evidence and may be split into follow-up work. How would you model states and events so closure, reopening, and splitting remain traceable?
- A business rule is corrected retroactively. Reports need corrected results, while decision-makers also need the results available at the time. How would you manage both historical views?
No questions in this section match your target. ·