Eight years at one company, and now a stranger wants you to reverse a linked list on a whiteboard or write a window function from memory. The skills are in there somewhere, you used them for years, but they have gone soft under layers of meetings, legacy systems, and the one narrow stack your old job actually needed. The panic says: fake it. The panic is wrong. Rust is recoverable in two weeks, and honestly labeled rust interviews better than fake fluency ever will. Here is the triage plan.
First, an honest inventory (one evening)
Before refreshing anything, find out what is actually rusty. Take a blank page and three columns:
- Sharp: used in the last six months, could discuss today.
- Rusty: used professionally before, would fumble under pressure.
- Gone or never had: listed on your resume out of optimism, or three versions out of date.
Now pull up the job descriptions you are targeting and mark which column each required skill falls in. This intersection is your entire prep plan. A returning developer usually discovers something encouraging here: the sharp column contains the expensive stuff (debugging judgment, system design, knowing how projects go wrong) and the rusty column contains the cheap stuff (syntax, method names, the mechanics of algorithms). Interviews unfortunately sample the cheap stuff heavily, which is exactly why targeted refresh works: you are not learning, you are reloading.
Be ruthless with the third column. Anything gone should come off your resume this week, because every listed skill is a question you might get, and nothing sinks an interview faster than fumbling a skill you claimed in writing.
The two-week refresh plan, ordered by what interviews actually test
Two weeks, roughly an hour or two a day, ordered so that if you run out of time, you cut from the bottom.
Days 1 to 3: core fluency in your primary language or tool. Write code (or queries) by hand daily, without autocomplete, because your fingers have forgotten what your editor has been doing for you. Engineers: arrays, strings, hash maps, loops, basic recursion. Analysts: joins, aggregation, window functions, and explaining a metric from scratch. Small daily reps beat weekend binges.
Days 4 to 7: the standard question patterns. Interviews draw from a bounded pool. Engineers: two pointers, sliding window, tree traversal, basic dynamic programming; roughly 20 to 30 easy-to-medium practice problems is a realistic refresh, not the 300 that first-timers grind. Analysts: metric investigation questions ("signups dropped 10 percent, walk me through it") and query problems against realistic schemas.
Days 8 to 10: talk while solving. This is the skill that decays most and gets tested most. Solve problems out loud, alone or with a friend, narrating your approach before you write anything. Interviewers score the narration as much as the solution; silent correct answers score worse than talked-through imperfect ones.
Days 11 to 12: design and experience questions. Your unfair advantage as a veteran. Prepare two or three real war stories: a system you built, an outage you debugged, a technical decision you got wrong and fixed. Rehearse them concisely. If your target rounds include open-ended business problems, the structure habits in case interview prep for non-consultants transfer directly.
Days 13 to 14: full dress rehearsal. Timed mock interviews, ideally with another person, in the actual format you will face (shared editor, whiteboard, or take-home). The rust that survives two weeks of study lives in performance conditions, so practice in them.
The honest script that outperforms faking it
Somewhere in the interview, you will hit a wall: a syntax detail, a method name, a concept you last touched in 2022. Here is the exact move.
"Honestly, I have not used this day to day since 2022, so my recall is rusty. Here is how I would approach it conceptually... and in practice I would confirm the specifics in the documentation."
Then keep reasoning out loud as far as you can. Compare that with the bluff: you improvise something plausible, the interviewer asks the natural follow-up, and now you are two layers deep in a fiction with your credibility draining. Interviewers are professionally good at follow-ups; that is the whole job. The bluff has no exit.
The honest script works because of what senior interviewers are actually screening for. They know skills date quickly and expect competent people to relearn fast. What they cannot fix later is a hire who papers over gaps, because those gaps surface in production instead of in interviews. A candidate who says "I do not remember, here is my reasoning, here is how I would verify" is demonstrating the exact behavior that makes a trustworthy colleague. You are not confessing weakness; you are auditioning judgment. More on this move in what to say when you do not know the answer in an interview.
One boundary: date your rust honestly. "Rusty since 2022" must be true. If you claim rust on something you never actually used, that is not rust, and the follow-up questions will find the difference.
Play to the strengths rust cannot touch
While you are anxious about syntax, remember what a decade of real work gave you that fresh graduates cannot fake:
- Debugging instinct. You have seen hundreds of failure modes. When an interviewer's code sample has a bug, you will smell it faster than someone with perfect algorithm recall.
- Design judgment. You know what happens to systems in year three: migrations, scale walls, the report nobody can retire. Steer design questions toward tradeoffs and operational reality; that is where you outclass the field.
- Requirements sense. Asking "what is this actually for?" before solving is a senior habit interviewers notice.
Structure your interview presence so these lead. When given any open problem, spend your first minute on clarifying questions and constraints. That minute plays as experience even while your syntax warms back up.
Your resume is claiming skills right now. Audit it.
Here is where rust hides in plain sight: the skills section you wrote years ago and have been copy-pasting since. Every keyword in it is a standing claim, and interviewers treat the resume as a menu of things they are allowed to probe. That "Kubernetes" you touched in one migration in 2023? It is on the menu.
Before your next application, audit every claim against one standard: could I survive ten minutes of friendly questioning on this? Keep what passes. Refresh what matters for the role. Cut or relabel the rest ("familiar with," "previously used in production") so the claim matches the reality you can defend.
The free Bounce scan at careerbounce.io makes this audit concrete. It shows you exactly what the hiring software parses from your resume, including every skill keyword you have claimed, in the same flat list a recruiter searches against. It runs entirely on your device; your resume never leaves your computer, and it costs nothing. Rusty skills become a problem only when they hide, on your resume or in your answers. Surface them, refresh the ones that matter, label the rest honestly, and you walk into the interview as what you actually are: an experienced professional two weeks back into fighting shape, with nothing on the page you cannot back up.