skip to content

A team moves its reporting engine off a managed tier onto plain rented machines - which duties does that hand back?

level: seniorimportance: must knowfreq 62%

answer

  1. managed was buying work, not features
  2. list what nobody used to do
  3. patching, failover, backups, capacity, on-call
  4. a restore is a duty, not a button
  5. host access gained, pager inherited

basics

~20 s

Everything the tier was quietly doing returns: patching the guest operating system and the engine, standby replicas and failover promotion, backups with a proven restore, capacity and sizing, engine health monitoring, and an on-call rota. The engine behaves the same; the operating burden does not.

solid answer

~50 s

The engine is the same software, so queries and storage behave as before. What changes is who performs the work the tier was doing invisibly: patching the guest operating system and the engine itself, tracking minor versions and end of support, building and rehearsing a standby replica with automatic promotion, taking backups **and proving a restore against the recovery time the business already assumes**, sizing and growing capacity, watching the engine's own health, and carrying a pager. The provider still owns the facility, the hardware and the hypervisor, so this is not unmanaged - the shared responsibility line simply moves down a rung and everything above it is yours. In exchange you get host access while diagnosing, the tuning knobs and extensions the tier disabled, the version you choose, and no ceiling set by a size class.

go deeper

for a junior

Recall that a managed tier performs work invisibly - patching, backups, failover - and that running the same engine yourself means somebody on the team performs it instead.

for a middle

Explain the mechanics of each returned duty: what a maintenance window used to apply, what a standby replica needs beyond replication, and why a backup is not a restore.

for a senior

Demonstrate that you would measure the duties rather than list them: rehearse a restore onto fresh machines, drill promotion, and check the measured times against what the business already assumes.

for a principal

Judge whether the organisation can carry the returned duties at all, and what staffing, rota and standard you set before approving any team's move off a managed tier.

## What the managed tier was actually selling A managed tier is usually described as a product, but what you were buying was **work you did not have to do**. That is why the invoice is the wrong place to look when you cost the exit: the line item disappears, and the work reappears somewhere that has no line item at all. The engine itself is not the difference. Run the same engine on a machine you rent and it parses the same queries, produces the same plans and writes the same structures to disk. The difference is entirely in the **duties**. ## The duties that come back | Duty | On the managed tier | After the move | |---|---|---| | Guest operating system patching | performed under a maintenance window | yours, including the reboot that applies it | | Engine minor versions and end of support | offered, scheduled, sometimes forced | yours to track, test and apply | | Standby replica and failover | built in, promotion automatic | yours to build, run and rehearse | | Backups and retention | configured once, taken for you | yours to schedule, store and expire | | Restore | offered as point-in-time restore | yours to perform and, first, to prove | | Capacity and sizing | a size class you select | machines, disks and headroom you plan | | Engine health monitoring | surfaced as service metrics | yours to instrument and alert on | | Being woken up | the provider's staff | your rota | ## The three duties discovered late 1. **A proven restore.** A backup job that runs is not a restore that works. The tier used to prove this by offering point-in-time restore as an action anyone could take. Self-running means somebody must restore onto fresh machines, time it, and compare that measured time against the recovery time objective the business already believes it has. Note the direction here: a standby replica is not a backup. Replication copies a deletion faithfully and protects against losing a failure domain; only a retained backup protects against a mistake. 2. **Failover promotion.** The engine can replicate - that capability is the engine's and it comes with you. What does **not** come with you is the thing the tier was doing around it: detecting that the primary is unhealthy, deciding that it is not a transient blip, promoting the standby, and moving clients onto the new primary. That is a system you now build, and a drill you now run. 3. **Version end of support.** On the tier, an upstream release going out of support usually arrived as a notice and a scheduled window - irritating, but somebody else's calendar. Self-running, nothing arrives. The version quietly ages until a security advisory forces an upgrade you have never rehearsed. ## Where the responsibility line now sits Self-running is not unmanaged. The provider still owns the building, the power, the physical hardware, the hypervisor and the network fabric; it still replaces a failed disk in a host. What moves is the boundary: on a managed tier the provider's duty reached up into the engine, and on a rented machine it stops at the hypervisor. **Everything above that line is yours**, including the parts nobody enumerated because they were never visible: the guest operating system's packages, its kernel updates, the clock, the file system layout, the process supervision, and the access control on the machine itself. ## What the move buys Be explicit about the other side of the trade, because a migration argued only in duties sounds like pure loss: - **Host access while diagnosing.** The thing an incident-shaped team misses most on a managed tier is the ability to look, rather than to open a support case and wait. - **Tuning knobs and extensions the tier disabled.** Managed tiers withhold settings that could destabilise a fleet; self-running returns them, with the risk that motivated withholding them. - **The version you choose**, on your schedule, rather than the versions the tier offers. - **No ceiling set by a size class.** This is usually why you are here in the first place. ## How to answer this in an interview Enumerate the duties rather than gesturing at "more ops work", and make the enumeration concrete: who patches, who is paged, who proves the restore, who promotes the standby. Then say the honest sentence that separates a senior answer from a confident one - the engine is unchanged, so no query gets faster by leaving; what changes is the operating burden and the ceiling. If you are asked what you would do first, say: rehearse a restore onto fresh machines and measure it, because that is the duty that is easiest to believe you already have and hardest to discover you do not.

  • Which of those duties is most often discovered late, and why?
    The restore. A backup job that runs is not a restore that works, and the tier used to prove that for you by offering point-in-time restore as an action. Self-running, somebody must restore onto fresh machines, time it, and compare that measured time with the recovery time objective the business already assumes it has. Nobody notices the gap until an incident measures it for them.
  • Does the team also inherit the machines themselves?
    In duty, not in ownership. The provider still runs the facility, replaces failed hardware and operates the hypervisor beneath your machine. What becomes yours is the guest operating system upward: its packages, kernel updates, the reboot that applies them, process supervision and access control on the host. The shared responsibility line moves down one rung, and nothing above it is done for you.
  • What does the move buy that the managed tier withheld?
    Host access while diagnosing instead of a support queue, tuning knobs and extensions the tier disabled to protect its fleet, the engine version you choose on your own schedule, and no ceiling imposed by a size class. Those are the reasons to go, and naming them explicitly keeps the trade argued rather than assumed.

saying these in an interview costs you the question

  • Says self-running is just installing the engine on a machine
  • Counts backups as solved because a snapshot job exists
  • Forgets that failover promotion stops being automatic off the tier
  • Believes the engine's own behaviour changes once you self-run it
  • Treats guest operating system patching as still the provider's job
  • Plans no on-call rota because the tier never paged anyone