Infrastructure Strategy and Technology Selection Questions
Setting technical direction for infrastructure and deciding what to build on. Covers infrastructure vision and long-term roadmap, modernization and technical-debt strategy, platform decisions, and organizational and governance considerations, alongside the decision framework for adopting or retiring technology: build-versus-buy-versus-cloud-versus-on-premises trade-offs, vendor and platform evaluation, technology-portfolio rationalization, requirements-driven service selection, and weighing total cost of ownership and risk. It also covers managing an existing vendor relationship: quantifying and mitigating lock-in, negotiating contract terms, and planning an exit from a service the organization depends on. The leadership-altitude discipline of directing an infrastructure estate over time, building consensus among stakeholders with conflicting priorities, and persuading leadership or a team to accept a major technology change.
What does a multi-year technical vision and infrastructure roadmap actually mean in practice, and how does it differ from a shorter execution plan? Describe the components you would expect to see (architecture direction, sequencing, governance, cost, risk) and the audiences each is written for.
Sample Answer
A technical vision is a directional statement over a multi-year horizon (typically 3-5 years): where the platform needs to end up and why, in enough detail to make trade-offs but not enough to lock in implementation. A roadmap sequences that vision into named phases with rough timing. An execution plan is the short-horizon (quarter or sprint) commitment of specific work items to specific owners. The three exist because they answer different questions for different audiences, and collapsing them into one document is the most common failure mode in practice.
The five components a real roadmap includes
- Architecture direction (the pillars): the small number of durable architectural bets the organization is making (for example "consolidate onto one data platform," "move from a monolith to domain-owned services"). This is the part that changes slowest and should survive most quarterly re-plans.
- Sequencing (milestones): the order phases happen in and why that order was chosen, usually because one phase is a technical or organizational prerequisite for the next. Milestones are the checkpoints a person outside the work can use to tell if it is on track.
- Governance: who approves scope changes, what triggers a re-plan, and what checkpoint cadence keeps the roadmap honest instead of becoming a document nobody revisits.
- Cost: a multi-year budget envelope (order of magnitude, not a line-item quote) tied to each phase, so a funding conversation can happen before the phase starts rather than mid-execution.
- Risk: the handful of things that could derail the plan (a key vendor's viability, a skills gap, a dependency on another team's roadmap) named explicitly, with an early-warning signal for each, not buried in prose.
A roadmap without an explicit KPI (key performance indicator) attached to each milestone is not falsifiable: nobody can tell six months in whether the phase actually succeeded or just shipped.
Audiences
- The vision is written for the people who fund and sponsor the direction: the CTO's peers, the board, other VPs whose roadmaps need to line up with it. They need the "why" and the trade-offs made, not the sequencing detail.
- The roadmap is written for engineering leadership and an architecture review body: people who need to plan their own team's work against the milestones and dependencies, and who will push back on sequencing if it conflicts with something they already know.
- The execution plan is written for the team doing the work this sprint: specific tickets, specific owners, specific acceptance criteria. Nobody outside the team needs this level of detail, and putting it in the roadmap document buries the signal a leadership audience actually needs.
Worked example
Suppose the vision is: "consolidate three regionally siloed customer data stores into one global platform within three years, to cut cross-region query latency and stop paying for duplicated storage and duplicated on-call coverage." The roadmap breaks that into Year 1 (build the unified platform's core and migrate the smallest region as a pilot, a $400K-order-of-magnitude phase), Year 2 (migrate the two remaining regions, contingent on the pilot's migration tooling proving reliable), and Year 3 (decommission the legacy stores and retire the redundant on-call rotation). Governance names the architecture review board as the approver of any scope change and sets a quarterly checkpoint against the milestone dates. Risk names "the pilot region's migration tooling doesn't generalize to the larger regions' data volume" as the single biggest threat, with a leading indicator (migration throughput measured during the pilot) to catch it early.
Now a new data-residency requirement lands mid-Year-1. It does not change the vision (the destination is still one global platform); it changes the roadmap's sequencing (the pilot region may need to move earlier or later depending on where the requirement bites hardest) and it is absorbed entirely inside the execution plan for the current sprint boundary, without anyone needing to touch the vision document at all. That containment, a change rippling only as far up as it has to, is the actual test of whether these three artifacts were built as separate things in the first place.
Trade-offs and pitfalls
- The most common failure is writing a "vision" that is really a roadmap with more adjectives: it names activities instead of making an actual directional bet with an explicit trade-off (what the organization is choosing not to do, and why).
- A vision that is never revisited ages badly. Review it on a fixed cadence (annually is typical), because the business strategy it's supposed to serve will have moved even if the technology hasn't.
- A roadmap with no stated non-goals turns into a wish list that absorbs every stakeholder's pet request, because nothing in the document says what's explicitly out of scope.
- Skipping the execution-plan layer and asking engineers to work directly off roadmap-level milestones leaves ambiguity about who owns what this sprint, which shows up later as missed dependencies nobody flagged in time.
A client in a regulated industry (e.g. subject to GDPR, HIPAA, or PCI-DSS) needs personally identifiable or sensitive data to stay within a specific jurisdiction or on-premises, while still wanting cloud-level scalability elsewhere. Propose a hybrid architecture and placement strategy that satisfies the regulatory constraint without abandoning the benefits of cloud.
Sample Answer
The way to satisfy a jurisdiction-locked or on-premises requirement without giving up the benefits of cloud is a hybrid architecture split along the data-classification boundary, not along a single all-or-nothing environment choice: keep the regulated personally identifiable data in a system of record inside the required jurisdiction or on-premises, run the compute-heavy and non-sensitive workloads in the cloud, and connect the two through a narrow, audited integration layer that never lets raw regulated data cross without a reason.
The placement strategy
- Classify the data first. Identify precisely which fields are the regulated data under the relevant law, HIPAA (Health Insurance Portability and Accountability Act, the US law governing protected health information), GDPR (General Data Protection Regulation, the EU law governing personal data of EU residents), or PCI-DSS (Payment Card Industry Data Security Standard, the security standard for handling cardholder payment data), versus which data is derived, aggregated, or properly de-identified and no longer carries the same constraint.
- Place the regulated data in a compliant system of record. That's either genuinely on-premises or in a cloud region and service explicitly covered by the needed compliance instrument, for example a signed business associate agreement (BAA, the contract HIPAA requires with any vendor handling protected health information) with a provider's HIPAA-eligible service, or a provider's region-locked residency guarantee for GDPR, with encryption keys kept under the organization's own control (customer-managed keys) even when the storage itself is cloud-hosted.
- Run everything else in the cloud. Analytics on de-identified or aggregated extracts, stateless application logic, and model training on properly anonymized data don't carry the same constraint and can use elastic cloud capacity freely.
- Build a narrow, audited integration layer. Move only the minimum derived data needed across the boundary, never raw regulated data, and log every crossing so the boundary itself produces the audit evidence a regulator would ask for.
- Design the exit posture in from the start. A regulator audit or a future vendor change shouldn't force re-architecting the regulated core, since that system of record is the part least able to tolerate disruption.
The key realization that makes this work is that the actual regulatory ask is usually evidence of control, key ownership, and data residency, not literal physical location; once that's separated from the stated position of "must be on-premises," several major cloud providers can satisfy it directly, though eligibility for any specific compliance instrument should always be verified against the provider's current documentation before committing, since it changes over time.
Worked example
A healthcare analytics company keeps patient records (protected health information) in an on-premises system of record within the required jurisdiction, with strict encryption and access logging. It runs population-level analytics, readmission-risk modeling across de-identified, aggregated cohorts, in the cloud, bursting to significant compute for periodic model retraining without owning that capacity year-round. The integration layer is a nightly batch job that extracts only the fields the model needs, already stripped of direct identifiers per the applicable de-identification standard, and writes them to a cloud storage location that only that pipeline's service account can reach, with every extraction and every access logged.
A payment company facing the same shape of problem under PCI-DSS keeps cardholder data in a segmented, PCI-DSS-scoped on-premises environment with region-specific key management under its own control, but runs its customer-facing website and general application logic in the cloud, tokenizing card data at the point of capture so the cloud-side systems only ever handle a token, never the real card number. That tokenization is what keeps the cloud environment itself out of PCI-DSS scope for that data, letting the company get cloud-level scale for everything except the narrow slice that actually has to stay controlled.
Trade-offs and pitfalls
- The boundary only holds if it's enforced structurally, through tokenization or a gateway service, rather than by policy alone; the most common failure is one convenient raw field crossing into the cloud side because a feature happened to need it and nobody stopped it at the architecture level.
- Assuming on-premises is the only way to satisfy a regulator, when the real requirement is evidence of control and key ownership, needlessly gives up cloud scale for the whole regulated system instead of just the part that actually needs it.
- An integration layer with no audit logging defeats the entire purpose of building a compliant boundary in the first place; the logging is not an add-on, it's the evidence the whole design exists to produce.
Procurement hands you a draft SaaS contract with a vendor-delivered custom feature backlog and no explicit data-export guarantee. As the technical reviewer, what contract clauses and negotiation priorities would you push for to protect the organization's ability to leave later?
Sample Answer
A draft software as a service (SaaS) contract with a custom feature backlog and no data-export guarantee is a lock-in risk hiding behind a features conversation, and the technical reviewer's job is to make the exit path a contractual right before signature, since it is nearly impossible to negotiate after the relationship is already dependent on the vendor.
Priorities to push for, in order
1. An explicit, enforceable data-export clause. The contract should name the exportable entities, the format (structured, documented, and machine-readable, not a one-time PDF dump), the maximum time the vendor has to fulfill an export request, and that this obligation survives termination for any reason including non-payment disputes. Without this clause, "we'll figure it out" is the vendor's leverage at the worst possible moment, mid-dispute or mid-migration.
2. A concrete extraction and migration runway, not just a promise. Before signing, have your own team produce a one-page data catalog of what would need to leave the vendor's system on day one of an exit: every entity, its approximate volume, and which internal or replacement system would receive it. This turns "can we leave" from an abstract legal question into a plan you have already rehearsed, and it tells you during negotiation exactly which export formats to demand, because you know precisely what a real migration would need to read.
3. Custom feature ownership and portability. If the vendor is building bespoke functionality specifically for this backlog, negotiate who owns the resulting configuration, code, or workflow logic; a vendor-owned custom feature you cannot take with you is a second, quieter lock-in on top of the standard product, and it is invisible until you try to leave and discover your workflows do not exist anywhere the export format covers.
4. Contract term length and price-escalation caps. A multi-year term with no escalation cap converts a manageable vendor relationship into a budget risk the moment renewal negotiations arrive with no competitive alternative lined up, since by then your own migration plan may have gone stale. Push for the shortest initial term the vendor will accept, a renewal cap on price increases (for example tied to a published index or a fixed percentage), and the right to terminate for cause if the vendor is acquired or materially changes the product, since an acquisition is exactly when roadmaps and pricing shift without warning.
5. Service continuity and transition assistance clauses. Require a defined transition-assistance period after termination (commonly 60 to 90 days) during which the vendor keeps the environment live and available for extraction runs, rather than the environment going dark the day the contract ends.
Worked example
Assume the vendor's draft says only "customer data will be made available upon request." A reviewer counters with: export format specified as CSV (comma-separated values) or a documented API (application programming interface) with a written schema; a 30-day service-level commitment on export delivery from request; explicit statement that this obligation survives termination; ownership of custom-built workflow configurations assigned to the customer; a 3-year initial term capped at 5% annual price escalation on renewal, with a right to terminate without penalty if pricing increases beyond that cap; and a 60-day transition-assistance window post-termination with the production environment kept read-accessible. Each of these closes one identified gap in the original draft: format ambiguity, timing ambiguity, survival ambiguity, ownership ambiguity, and the two commercial risks (uncapped renewal pricing and a hard cutoff at termination).
Trade-offs and pitfalls
Pushing every clause above will slow the deal and may cost negotiating leverage on price or the custom feature timeline, so prioritize by blast radius: the export-format and survival clauses are non-negotiable because their absence is catastrophic and undetectable until the exit is already underway, while the price-escalation cap is important but recoverable (you can walk away at renewal if you kept your migration plan current). The common pitfall is treating this as a legal-only exercise: procurement and legal cannot write a meaningful export-format clause without engineering specifying what "usable" export actually means for this system, so the technical reviewer's job is to hand legal the concrete requirements, not to defer the whole clause to boilerplate.
You have a backlog of infrastructure work items competing for the same limited engineering capacity (for example 'improve alerting', 'migrate a legacy tool', 'optimize a slow system', 'add a missing catalog'). Describe a prioritization framework: how you'd score items and who you'd involve in the decision.
Sample Answer
Direct answer
Score every backlog item on the same small set of axes so heterogeneous work (alerting, a migration, a performance fix, a missing catalog) becomes comparable, and involve a small, named group rather than a broad committee: the requesting team's lead for effort, the on-call or reliability lead for risk impact, and the engineering manager or platform lead as the tie-breaker.
Structured elaboration
A workable scoring model
Score each item on three axes, 1 to 5:
- Risk/reliability impact: how much incident exposure or operational pain this removes if done, and how much it grows if left undone.
- Urgency: whether a deadline, compliance requirement, or growing blast radius makes delay costly on its own.
- Effort: estimated engineer-weeks, inverted in the score so smaller effort scores higher.
Composite score: Priority=Effort (engineer-weeks)Risk+Urgency, ranking items by cost-adjusted impact rather than raw impact alone, so a high-impact item that would consume a quarter does not automatically beat three smaller high-impact items.
Who scores what, and who decides
- The requesting team's tech lead estimates effort, since they know the work best.
- The on-call or SRE (site reliability engineering) lead estimates risk impact, since they see the incident data across teams that any one team's lead does not.
- The engineering manager or platform lead breaks ties and owns the final sequencing, especially when two items score close but only one has capacity this cycle.
Worked example
Four items, scored independently before any group discussion (independent scoring first is deliberate, covered below): "improve alerting" (Risk 4, Urgency 3, Effort 2 weeks) scores (4+3)/2=3.5. "Migrate a legacy tool" (Risk 2, Urgency 2, Effort 6 weeks) scores (2+2)/6≈0.67. "Optimize a slow system" (Risk 3, Urgency 4, Effort 3 weeks) scores (3+4)/3≈2.33. "Add a missing catalog" (Risk 2, Urgency 1, Effort 1 week) scores (2+1)/1=3. Ranked: alerting (3.5), the missing catalog (3.0), the slow system (2.33), the legacy migration (0.67) is last, not because it is unimportant but because its cost-adjusted score is currently low; it stays visible on the backlog for re-scoring once effort drops (for example, if a newer migration tool cuts the estimate to 2 weeks) or urgency rises (a security or vendor deprecation deadline attaches to it).
Trade-offs and pitfalls
The biggest failure mode is letting scoring happen in a group discussion where the loudest or most senior voice anchors everyone else's numbers; score independently first, then discuss only the items where scores disagree sharply. A second failure is over-engineering the framework itself, a full quarterly-planning ritual is overkill for a rolling backlog this size; a lightweight, repeatable scoring pass beats a heavyweight process nobody keeps up. Without any framework at all, the default outcome is that the loudest stakeholder's request wins regardless of actual impact, which is the exact failure this framework exists to prevent.
After a major technology change (a refactor, a platform migration, or a switch to a managed service), how would you prove - not just assert - that it improved reliability, cost, or developer velocity? Describe the baseline metrics, control approach, and statistical rigor you'd use, and how you'd report the result to stakeholders.
Sample Answer
Proving that a technology change improved reliability, cost, or developer velocity requires the same discipline as any causal claim: a baseline captured before the change, a comparison that isolates the change from everything else happening at the same time, and a report that states the uncertainty honestly instead of presenting a single before-and-after number as fact.
Baseline, control, and rigor
Capture the baseline before the change ships, not after. Record the metric over a period long enough to see its natural variation (commonly 4 to 8 weeks, or long enough to span at least one full business cycle such as a weekly or monthly peak), because a single pre-change data point cannot tell you whether post-change movement is the change or ordinary noise.
Use a control where one is available, and be explicit when one is not. The strongest design is a staged or canary rollout, where part of the traffic or part of the team migrates first while the rest continues on the old system under identical external conditions during the same window; this isolates the change from confounders like a holiday traffic dip or an unrelated incident elsewhere in the stack. When a true control is impossible (for example a single monolith-wide platform migration with no way to run half the org on the old system), say so explicitly and rely instead on an interrupted-time-series comparison: the same metric, same team, same season, immediately before and after, with any known confounding event during the window called out by name rather than absorbed silently into the result.
Pick metrics that match the claimed benefit, and use more than one. For reliability: incident count and mean time to recovery, plus the error-budget burn rate against the service's service-level objective, or SLO (the reliability target you've committed to, for example 99.9% uptime per month). An error budget is the amount of allowed failure that target implies (0.1% of the month, in this example), and the burn rate is how fast you're consuming it: a rate of 2x means you're on pace to use up a month's entire allowed failure in half a month, which is the signal most teams use to slow down risky changes. For cost: total infrastructure spend normalized per unit of traffic or per customer, not raw spend, since raw spend conflates cost efficiency with growth. For developer velocity: deployment frequency, lead time for changes (time from commit to production), and change failure rate, three of the four metrics the DevOps Research and Assessment (DORA) research program tracks (the fourth, time to restore service, is the same failure-recovery signal already captured above as mean time to recovery), plus a qualitative measure such as a developer survey on perceived friction, since a purely quantitative velocity number can improve while developer experience quietly worsens in a way the metric does not capture.
State statistical rigor honestly. Report the baseline period's own variance (for example "incident count varied between 3 and 9 per month in the six months before the change") alongside the post-change number, so a reviewer can judge whether the observed shift is larger than the system's normal noise, rather than reporting only two point estimates and letting the reader assume any difference is meaningful.
Worked example
A team migrates a service from self-managed virtual machines to a managed container orchestration platform, claiming it will improve deployment frequency. Baseline: over the 8 weeks before migration, the team shipped a median of 3 deployments per week, ranging from 1 to 6. They run a staged migration, moving one of three service instances to the new platform while the other two stay on the old one for the same 6-week window, so external factors (a product launch, a holiday freeze) affect both groups equally. Post-migration, the migrated instance's owning team ships a median of 9 deployments per week over that window, versus a median of 4 for the two teams still on the old platform during the identical window. Because both groups experienced the same external conditions, the roughly 2x differential (not the raw 3-to-9 jump, which could partly be a general uptick) is the number attributable to the platform change, and it is reported to stakeholders as "deployment frequency increased by approximately 2x relative to a matched control group over the same 6-week window," with the baseline range disclosed alongside it.
Trade-offs and pitfalls
The honest version of this analysis takes longer and produces a less dramatic headline than "deployments went from 3 to 9 a week," so there is real organizational pressure to skip the control and report the bigger, uncontrolled number; resist it, because a claim that does not survive a skeptical rereading damages the credibility of every future measurement from the same team. A common pitfall is picking the metric after seeing which one moved favorably, which turns measurement into storytelling; commit to the metric and the comparison design before the change ships. Reporting to stakeholders should lead with the plain-language claim and its confidence level, then the supporting numbers, since a wall of statistics with no headline is as ineffective as a headline with no statistics behind it.
Unlock Full Question Bank
Get access to all Infrastructure Strategy and Technology Selection interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.