skip to content

In a design system, a deprecated data table's removal release arrives with thirty usages left across five teams' apps; what do you do?

level: seniorimportance: should knowfreq 26%

answer

  1. find out why each remains
  2. whose blocker is it?
  3. counts per team, published
  4. stragglers can stay on the old major
  5. time-boxed extensions, recorded

basics

~20 s

Find out why each usage remains, then act by cause: fix gaps in the replacement or codemod, help with hard cases, and otherwise remove in the announced major release, since unmigrated teams can stay on the previous major briefly.

solid answer

~40 s

First I would find out **why** each of the thirty usages remains, because the right response depends on whose problem it is. If the replacement cannot do something the old table did, say row grouping for expense reports, that is the system's gap: fix it, or grant a time-boxed extension for those usages. If the codemod failed on certain patterns, fix the codemod. If teams simply did not prioritise the work, keep the published date: removal in a **major release** does not break anyone who does not upgrade, so they can stay on the previous major briefly while they migrate, missing later changes unless fixes are backported. Throughout, publish per-team counts, and afterwards review why the window was not enough so the next deprecation goes better.

go deeper

for a junior

Recall that remaining usages of a deprecated component are tracked, and that removal happens in a major release announced in advance.

for a middle

Explain why removal in a major release does not break teams that do not upgrade, and what staying on the previous major costs them.

for a senior

Show the diagnosis by cause: system-side blockers get fixes or time-boxed extensions, team-side delays get help but keep the date, and counts stay visible throughout.

for a principal

Treat a missed removal as feedback on the deprecation policy itself, and weigh firm dates against the risk of pushing teams into private forks.

## The situation A **design system** deprecated its old data table in favour of a new one, published a migration guide and a codemod, and announced removal for the next major release. That release is now ready, and a scan of consuming codebases on a travel-expense tool still finds **thirty usages** across five teams: the expense report list, the approvals queue, the finance export screen and two admin tools. Shipping the removal as-is, or quietly postponing it, are both tempting and both usually wrong. The first step is diagnosis. ## Why usages remain | Reason | Whose problem | Response | |---|---|---| | The replacement lacks a capability, such as row grouping | The system's | Close the gap, or grant a time-boxed extension for those usages | | The codemod fails on a common pattern | The system's | Fix the codemod and rerun | | The migration guide misses a case teams hit | The system's | Update the guide, help the affected team | | The team knew but did not schedule the work | The team's | Keep the date; offer help, not an extension | | The team never heard about the deprecation | Both | Check the communication path, then decide | Splitting usages this way usually shows that most remaining work sits in a few teams and a few causes. ## Tracking remaining usages This decision is only possible if usages were tracked all along: - **Code scans** across consuming codebases, counting references to the deprecated component per team and per codebase. - **Flagged cases** left by the codemod, counted separately, since they are the hard part. - **Design library usage**, since designs that still use the old table will produce new code that uses it. - **A visible trend**, published with each release, so teams and their managers see progress, and flat lines prompt a conversation early rather than at the deadline. ## Deciding the removal 1. **Resolve the system's blockers first.** If the replacement cannot do the job, holding teams to the date is unfair and will push them to copy the old table into their code. 2. **Help with the hard cases.** Pair with the teams that own the flagged usages; often a few hours of help clears most of them. 3. **Grant extensions only by rule.** Extensions should be time-boxed, tied to a system-side blocker, and recorded, not handed to whoever asks loudest. 4. **Remove on schedule otherwise.** Postponing for teams that simply did not prioritise the work teaches every team that dates are soft, which makes every future deprecation slower. ## What removal at a major means for stragglers Removing the component in a **major release** does not break anything already installed. A team that has not migrated breaks only when it upgrades to the new major, so it can stay on the previous major while it finishes. The cost is that it misses whatever the new major and later releases bring, unless the system team backports fixes to the previous major. Many systems therefore define a limited period of fixes for the previous major, often only for severe and accessibility defects, which gives stragglers time without making the old version a permanent home. ## Preventing it next time After the removal, review the deprecation itself: - Was the window long enough for a component this widely used? - Did the replacement reach feature parity before deprecation started? - Did the codemod handle the patterns teams actually use? - Did every team hear about it, including teams that rarely read release notes? It also helps to look at when usages fell. If most teams migrated in the last two weeks, the window length mattered less than the reminders, and earlier, targeted nudges will do more next time than a longer window. If a few usages never moved at all, the issue is usually a blocker nobody reported, which argues for asking teams about blockers early instead of waiting for the count to fall. The answers feed back into the deprecation policy. Thirty usages at the deadline is a signal about the process as much as about the teams, and the most useful outcome is a next deprecation that finishes on time.

  • Why is quietly postponing the removal for everyone usually a mistake?
    It rewards teams that ignored the window and punishes those who migrated on time, and it teaches every team that removal dates are soft. The next deprecation then gets less attention, and the system carries the old component, with its maintenance cost and its design inconsistency, far longer than planned.
  • How long should the previous major keep receiving fixes after a removal?
    It is a policy choice, but it should be limited and published: for example, only severe and accessibility defects for a fixed period. Long enough that stragglers can finish migrating without being exposed to serious bugs, short enough that the previous major does not become a second product the system team maintains indefinitely.

saying these in an interview costs you the question

  • Remaining usages at the deadline are always the consuming teams' fault.
  • Removing the component in a major release breaks every straggler immediately.
  • Postponing removal for everyone is the kindest and safest choice.
  • Remaining usages only need counting on the day of removal.
  • Any team that asks should get an open-ended extension.