Interview guides · American Iron & Metal

American Iron & Metal Software Engineer Interview Guide

American Iron & Metal Software Engineer interview guide: three reported rounds, the questions candidates report and a 7-day prep plan with answer outlines.

The 60-second brief

American Iron & Metal is described by candidates as a metal recycling and processing business. Software there supports logistics, inventory and supply chain work, and the Software Engineer role centres on internal tools: building and maintaining them, debugging existing systems, automating manual processes and keeping data in internal databases correct. The people who use those tools include maintenance managers and operations leads, so the work is tied to how material and equipment move through the business.

This guide is for engineers interviewing for the Software Engineer role at American Iron & Metal. It covers the three reported rounds (Initial Screen, Technical Assessment, Cultural Alignment Meeting), the six questions candidates report, and a seven-day plan. Candidates describe no specific language or framework requirement, only proficiency in at least one major language and a track record of maintaining production software, so the guide concentrates on how you explain your own work.

Candidates report three rounds over roughly 3-5 weeks: a recruiter screen, a technical assessment with hiring managers or team leads, and a cultural alignment meeting with HR leadership. Some candidates report a much faster process.

Focus areas

Self-introduction (Tell me about yourself)
Behavioral interview skills
Interview communication (professionalism)

Overview

The reported questions are conversational. They ask about your past experience, a hard technical problem you solved, how you debug and maintain legacy systems, and how you add new features to existing operational workflows. No coding exercise or take-home appears in the reports, so preparation means building a small set of well-rehearsed project stories and a clear method for troubleshooting, not grinding algorithm problems.

The work described is internal tooling for an industrial business: fixing existing systems, automating manual steps and keeping data in internal databases trustworthy. That shapes which stories land. A bug in an inventory or material-tracking tool has a physical consequence, a rollout changes how a maintenance or operations team does its day, and a data fix has to be checked against what is actually on the floor. Pick examples where you can describe the user, the data and the result, not only the code.

Candidates also report that some interviewers come from non-technical departments, and that the requirements stress clear communication with maintenance and operations staff. Practise each technical story twice: once with the engineering detail for a team lead, and once in plain language for a manager who has never read your code. Be ready for follow-up questions on any line of your resume, since reports say involvement is checked.

Finally, the nice-to-have skills candidates list are database management, legacy modernization and experience in industrial or logistics settings. If you have any of these, make them easy to find in your introduction. If you do not, prepare an honest bridge: the closest system you maintained, the data you kept correct, and what you learned about the people who relied on it.

The American Iron & Metal interview process

Candidates describe three stages, from a recruiter conversation to a technical assessment to a cultural meeting. Treat the order as reported experience, not a published process.

Initial Screen

Candidates describe the Initial Screen as a conversation with a recruiter about your background and qualifications. Approach it as the first telling of a story you will need to repeat consistently in every later round: who you are as an engineer, what you have maintained or built, and why this kind of work interests you. A self-introduction and a short account of past experience are the material to have ready.

What to demonstrate

How clearly you summarise your background and qualifications
How your past work lines up with building and maintaining internal tools
Resume-to-role alignment: whether your listed experience matches what you describe aloud

How to prepare

Write a present, past, future self-introduction and rehearse it aloud until it holds up without notes.
Prepare a one-sentence reason for wanting industrial or logistics-style software work, and read up on what metal recycling and processing involves.
Check each line of your resume against what you could explain in detail if asked about your own involvement.

Technical Assessment

Candidates describe the Technical Assessment as an in-depth technical evaluation with hiring managers or team leads. The reported material is discussion based: maintaining legacy systems, integrating new features into operational workflows, troubleshooting in production and the technologies on your resume. No coding exercise or take-home is mentioned. Approach it by preparing a few projects at the level of decisions: what you chose, what you rejected and what happened.

What to demonstrate

Troubleshooting method for finding root causes in production systems
Approach to refactoring and updating older codebases
How software connects to physical operational data and existing workflows
Depth on the technologies listed on your resume

How to prepare

Pick one hard problem you solved and outline the problem, the options you weighed, your choice and the measured result.
Write a repeatable debugging sequence for a legacy system: reproduce, check recent changes and logs, narrow by bisection, fix, add a regression check.
Outline how you would add a feature to a live workflow: who uses it today, a pilot, data migration, rollback and handover to the users.
For each technology on your resume, prepare one decision you made with it and one thing you would change now.

Cultural Alignment Meeting

Candidates describe the Cultural Alignment Meeting as a conversation with HR leadership to confirm fit with company culture, and report that some loops include it and some do not. The topics candidates list are project ownership, collaboration, how you handle disagreement with team leads or other departments, how you take feedback and how responsive you are. Approach it with a few short stories that each end in a clear outcome.

What to demonstrate

Project ownership from first request through deployment
How you handle disagreement with team leads or other departments
Clarity and professionalism of how you communicate
Responsiveness and follow-through

How to prepare

Prepare an ownership story with a clear start, the deployment and the outcome, including what you personally decided.
Prepare a disagreement story that ends with a resolution based on evidence, not on who was more senior.
Practise explaining one technical decision in plain language to a maintenance or operations manager.
Write two questions about how engineers and operations staff work together day to day.

Where candidates lose points

Answering the self-introduction as a chronological resume recital

Open with what you do now, pick two earlier experiences that explain it, and end on why internal tooling for an operational business appeals to you. Cut any job that does not support that line.

Telling the technical challenge story without the decision or the result

Structure it as problem, options you considered, the one you chose and why, and a measured outcome. Be ready to say what you would change, since explaining why you chose a solution matters as much as the solution.

Answering a legacy-system question with 'I would rewrite it'

Describe the order of work first: reproduce the fault, read logs and recent changes, narrow it by bisection, fix it, add a regression check, and only then say what you would refactor and how you would keep the system running while you do it.

Explaining a feature rollout as code only, with no mention of the people who use the workflow

Name the users (for example maintenance or operations staff), how you learned their current steps, how you piloted the change, how you migrated data and how you would roll back. Show the workflow before and after.

Using jargon with a non-technical interviewer, or claiming more involvement than you had

Prepare a plain-language version of every project story and a precise statement of your own part in it. Reports say resume details get follow-up questions, so every claim must survive three more questions.

Questions & practice

Canonicalise a request body into a stable idempotency fingerprint

Medium · parsing · canonicalisation · hashing

idempotency_key.request_fingerprint is a SHA-256 over the method, path and canonicalised body, and a retry whose fingerprint differs must be rejected with 422 rather than served the stored response. Write the canonicaliser. Bodies are JSON up to 256 KB nested at most 32 levels; clients vary key order, whitespace and unicode escaping, and some send 64-bit ids as JSON numbers. Produce a deterministic byte string such that semantically identical bodies match and any semantic difference does not. State your complexity and name two normalisations you refuse to perform.

Approach

Parse once into a tree, then re-serialise under fixed rules: object keys sorted, array order preserved, one escaping convention, no insignificant whitespace. Parsing is O(n) and sorting keys is O(k log k) per object, so O(n log n) overall with O(depth) stack, and the 32-level cap is enforced during parsing because hostile nesting is how a canonicaliser becomes a stack overflow.
Sort keys by their UTF-8 bytes and say why the obvious implementation is wrong in some runtimes: a default string comparison that orders by UTF-16 code units places surrogate pairs, meaning code points from U+10000 up, below U+E000 to U+FFFF, which is not UTF-8 byte order, so two services written in different languages disagree on the same document.
Do not re-encode numbers through a double. IEEE-754 binary64 represents integers exactly only up to 2^53, so normalising a 19-digit id through a float changes it, and 1 against 1.0 cannot be reconciled without deciding whether they are the same value. Preserve the literal token, and require ids as strings at the API boundary if you want them comparable.
Reject duplicate keys rather than picking one. JSON permits them and parsers disagree, most keeping the last, so any choice you make ties the fingerprint to a parser detail that the code handling the request does not necessarily share.

Follow-up

A client sends the same logical request with an extra field your API ignores. Same key, different fingerprint, so you return 422. Is that the right answer?
Where does the fingerprint get computed relative to request decompression and the body-size limit?

Diff a projection against the primary without per-row point reads

Hard · reconciliation · range hashing · throttling

The listing projection has drifted and some rows show a stale version. The primary holds 40,000,000 resource rows across 12,000 tenants while serving 1,200 writes and 14,000 reads per second. The obvious repair, reading each resource row and comparing its version against the projection, is correct and would eventually finish. Explain precisely why it is unacceptable here, then give a diff that finds the differing rows, state its complexity, and make it safe to run against a live primary. Replication lag is usually under 100 ms and is not bounded.

Approach

Quantify the naive cost rather than calling it slow: 40,000,000 point reads at even 0.5 ms each is over five hours serialised, and the only lever is concurrency, which is exactly what you cannot spend. The primary's pool is sized for the write path, and 40,000,000 random reads evict the buffer cache that sustains the 85 percent cache hit rate, so the audit degrades the system it is auditing.
Replace random access with one ordered pass per side. Both sides can be read in (tenant_id, resource_id) order, which is a sequential scan on each and a merge join in O(n) time and O(1) memory. For a dense diff that is the whole answer, and it reads the primary once instead of 40,000,000 times.
For the expected sparse case, compare range hashes instead of rows: partition the key space, compute per range an order-independent aggregate over hash(resource_id, version), compare aggregates, and descend only into ranges that differ. With d differing rows and branching factor B, at most d ranges mismatch per level, so the drill-down examines O(d log_B(n/d)) ranges and reads full rows only in mismatching leaves.
Aggregate with a sum modulo 2^64 or a multiset hash, never XOR. XOR is order-independent but self-cancelling, so two rows wrong in the same way, or a row duplicated on one side, leave the range aggregate matching and the range is declared clean.

Follow-up

The diff reports 900 stale rows. How do you decide between patching those rows and rebuilding the projection from resource_revision?
Same job, but the projection lives in a search index that cannot be scanned in key order. What changes?

Find overlapping job attempts and peak concurrency from lease records

Medium · sweep line · intervals · leases

A day of job_run history yields about 50,000,000 attempt records: (job_run_id, job_type, attempt, started_at, finished_at which is NULL when the worker died, lease_expires_at). Leases expire on a clock, so a job that outran its lease ran twice. Produce (a) every job_run_id whose attempts overlapped in wall-clock time and (b) the peak number of simultaneously running attempts per job_type with the minute it occurred. Target O(n log n). State how you treat a NULL finished_at and what clock skew does to your answer.

Approach

Define the interval before sorting anything: an attempt occupies [started_at, COALESCE(finished_at, lease_expires_at)). finished_at is observed and lease_expires_at is only a promise, so every attempt without a finish contributes an estimate and the whole result is a lower bound on overlap rather than an exact count.
For peak concurrency, sweep: emit 2n endpoints, sort by (timestamp, kind) with ends ordered before starts at equal timestamps, then walk the sequence maintaining a counter per job_type and record each type's maximum with its timestamp. O(n log n) dominated by the sort, O(n) space, or O(1) extra if the sort is external and the walk streams.
For overlap detection, do not compare attempts pairwise. A single global sort by (job_run_id, started_at) gives both the grouping and the order; within a group, keep the maximum end seen so far and report an overlap exactly when the next start is less than that running maximum, which is one linear pass after the sort.
Half-open intervals matter and are easy to get wrong: with closed intervals an attempt ending at the same millisecond another begins reads as concurrency two, and across 50,000,000 records that artefact swamps the real signal.

Follow-up

A handler is not idempotent and you have found 400 overlapping jobs. Which of them actually caused damage, and what would you query to find out?
Peak concurrency for one job_type is 4 against a configured cap of 4. Is the cap working, or is the data hiding attempts that never started?

Keep soft-deleted accounts from blocking re-registration

Easy · soft delete · unique constraints · engine differences

app_user holds user_id, tenant_id, email CITEXT, password_hash (NULL for SSO principals), email_verified_at, auth_version, status ('invited','active','suspended','deactivated'), created_at, updated_at, deleted_at. Two live accounts for one address inside a tenant must be impossible, but an address freed by a soft delete must be reusable, and the same tenant may delete and re-register it repeatedly. Write the uniqueness DDL for PostgreSQL 16, then the equivalent for MySQL 8 where partial indexes do not exist, and say what each permits once three deleted rows already hold that address.

Approach

Start from what is actually unique: not (tenant_id, email), but (tenant_id, email) among live rows. PostgreSQL says that directly — CREATE UNIQUE INDEX app_user_live_email ON app_user (tenant_id, email) WHERE deleted_at IS NULL. A full constraint over the same two columns burns the address permanently the first time someone deletes an account.
Keep case-insensitivity in the type or the index, never in the application: CITEXT as given, or UNIQUE (tenant_id, lower(email)) as an expression index where the extension is unavailable. A case-sensitive unique column is exactly how two accounts for one human appear.
For MySQL 8 the predicate has to move inside the key: add a discriminator column that is a constant 0 while the row is live and is set to user_id on delete, with UNIQUE (tenant_id, email, deleted_marker). Live rows share the constant and still collide; deleted rows differ from each other and stop colliding.
State the NULL variant and its dependency: leaving the marker NULL for deleted rows also works, because a unique index treats NULLs as distinct — true in MySQL, and true in PostgreSQL only under the default NULLS DISTINCT, which PostgreSQL 15 lets you reverse. Check the polarity against the three existing deleted rows: constant-on-live is what preserves the collision you want, and reversing it silently admits duplicate live accounts.

Follow-up

A deleted account re-registers with the same address the next day. Do the old resource rows follow the new user_id, and how does the API keep the two principals apart?
How do you honour an erasure request while resource_revision.actor_user_id still references this table?

Denormalise tenant onto revisions and backfill it live

Hard · denormalisation · online migration · backfill

resource_revision (revision_id, resource_id, version, actor_user_id, change_kind, patch, request_id, created_at) has 400M rows and no tenant column; tenant_id lives only on resource. Two reads need it: a tenant-scoped audit feed ordered by created_at DESC, and an offboarding purge. Both join back to resource today. Justify adding tenant_id to resource_revision against those two reads, name the anomaly the copy introduces and the constraint that prevents it, then give the ordered migration for a live table taking 1.2k writes/second — the lock each step takes, how the backfill is batched, and where each step stops being reversible. PostgreSQL 16.

Approach

Justify from the access path rather than from taste. Without the column, the audit feed either scans resource_revision by created_at and discards other tenants' rows, or resolves the tenant's resource_ids first and probes with them — both proportional to the tenant's whole history rather than to one page. With (tenant_id, created_at DESC, revision_id DESC) it is a seek that stops at 50 rows, and the purge becomes a ranged delete instead of a join.
Name the cost exactly: a second copy of a fact can disagree with the first. Make the disagreement unwritable rather than documented — add UNIQUE (resource_id, tenant_id) on resource so it can serve as a foreign-key target, then FOREIGN KEY (resource_id, tenant_id) REFERENCES resource (resource_id, tenant_id) on the revision table. A revision can then only ever carry its parent's tenant.
Step one, expand: ALTER TABLE resource_revision ADD COLUMN tenant_id BIGINT NULL, with no default, so it is a catalogue change and no rewrite. It still needs ACCESS EXCLUSIVE for an instant, and that instant queues behind the longest open transaction on the table while every later query queues behind it — set lock_timeout to 2s and retry rather than wait.
Step two, dual-write: deploy the writer that populates tenant_id on every new revision while reads still use the join. Reversible by redeploying the previous build, because nothing reads the column yet.

Follow-up

The backfill is half finished and a rollback is required. What state is the table in, and what does the previous build do with a half-populated column?
How do you verify the backfill actually finished, given rows are still being inserted while it runs?

What were your past experiences?

Medium · Background and Experience

Approach

Go through your roles in reverse chronological order. For each one, give the system you worked on, the part you personally owned, the main technology and one result you can measure (records processed, manual hours removed, incidents reduced). Keep each role to a few sentences and spend the most time on the most recent one.
Use "I" for your own work and "the team" for shared work. If a project was a group effort, say which module, query, service or migration you wrote yourself, so a follow-up about your level of involvement has a clear answer.
Lead with experience that matches the work candidates describe for this role: internal tools, database work and data integrity, automating manual processes, and maintaining or modernising older systems. Name the concrete artifact, for example "I replaced a spreadsheet import with a validated batch loader that rejected malformed rows".
For every technology you mention, have one specific detail ready: a schema you designed, an index you added and why, a bug you fixed. Any line on your resume can be asked about, so drop a technology from your answer if you cannot back it with a detail.
Close with the thread that links your roles (for example, building tools that non-engineers rely on every day) rather than a list of job titles.

Follow-up

Which part of that project did you build yourself, and what did someone else build?
What was the hardest production problem in that role, and how did you find the cause?
Why did you leave that role, and what did you want to do next?

How does your previous technical background relate to our current software infrastructure?

Medium · Background and Experience

Approach

You may not know this employer's internal stack, so start by mapping your experience to the work candidates describe for the role: internal operational tools, inventory and logistics data, internal databases, and maintaining older systems. Then ask the interviewer which languages, databases and systems the team runs today.
Match at the level of problems, not brand names. "I have kept a relational database consistent while several tools wrote to it" carries over even when the database engine is different. Give one example for each match: a constraint or transaction you used, a reconciliation job you wrote, a legacy module you refactored.
Name your gaps honestly and pair each one with a ramp-up plan: how you learned the last unfamiliar stack, what you read first (schema, deploy scripts, logs), and what you shipped in your first weeks.
Show that you can work out an existing system on your own. Describe the order you would read it in: data model first, then the entry points that write to it, then the scheduled jobs and integrations. Explain that this tells you where data is created and changed before you touch any code.

Follow-up

Which part of our stack would take you longest to get productive in, and how would you shorten that?
Tell me about a time you joined a codebase with no documentation. What did you read first?
How would you decide whether to modernise a legacy tool or keep maintaining it?

Can you walk us through a complex technical challenge you solved in a previous role?

Medium · Technical Proficiency

Approach

Pick one problem where you made the key technical decision. Open with the symptom and a number: for example, "inventory counts drifted from physical counts by a few percent each week", or "a nightly job grew from minutes to hours".
State the constraints before the solution: no downtime allowed, a legacy schema you could not change, users relying on the tool mid-shift, a fixed deadline. Constraints are what make the challenge complex, so name them explicitly.
Walk through how you found the cause. Say what you measured, which hypothesis you ruled out and with what evidence (query plan, logs, a reproduction). For example, finding duplicate writes from client retries and fixing them with a unique key on a request identifier plus an idempotent insert.
Give at least two options you considered and the trade-off that decided between them: index versus denormalised summary table, rewrite versus incremental refactor, synchronous versus batched processing.
End with how you verified the fix (before and after metrics, a reconciliation query that returned zero mismatches, a monitoring alert that went quiet) and one thing you would do differently.

Follow-up

What evidence told you the root cause was right and not just correlated with the symptom?
If the data had been ten times larger, which part of your solution would break first?
Who outside engineering was affected, and how did you keep them informed?

What is your process for integrating new software features into existing operational workflows?

Medium · Technical Proficiency

Approach

Start with the workflow, not the code. Spend time with the people who use the current process (candidates describe this role working with maintenance and operations staff) and write down each step, who does it, and what happens when it fails. The feature has to fit those steps or replace them deliberately.
Make schema changes backward compatible using expand and contract. Add new nullable columns or tables first, deploy code that writes to both the old and new paths, backfill, switch reads, and remove the old path only once nothing uses it. This avoids breaking older tools that share the database.
Release behind a feature flag to one pilot group first. Where the feature replaces a manual step, run it in parallel with the manual process for a period and compare the outputs, for example with a reconciliation query that lists every mismatch, before you remove the manual step.
Plan for failure in operational use. Writes should be idempotent so a retry or a double-click cannot create duplicate records, there should be a clear way to fix an entry made in error, and the rollback is to turn the flag off, not to roll back the database.
Finish with adoption: a short walkthrough or one-page guide for non-technical users, a channel for reporting problems, and a metric that shows the feature is being used and working (manual entries removed, errors per week).

Follow-up

What would you do if the operations team kept using the old process after launch?
How would you roll back if the new feature had already written data in the new format?
How would you test a change to a workflow you cannot fully reproduce outside production?

How do you approach debugging or maintaining legacy systems?

Medium · Technical Proficiency

Approach

Reproduce the problem first. Get the exact input, user, time window and environment, then reproduce it locally or against a copy of production data before forming a theory. If you cannot reproduce it, add logging around the suspected path and wait for the next occurrence.
Establish what changed: recent deploys, configuration, data volume, upstream file formats, a scheduled job's timing. If a known-good version exists, git bisect finds the first bad commit in about log2(n) test steps, which is around 10 for 1,000 commits.
Before changing legacy code, write characterisation tests that pin its current behaviour, including behaviour that looks odd, because users or downstream reports may depend on it. Then make the smallest fix and confirm that those tests still pass, except the one you meant to change.
For maintenance rather than a single bug, refactor in small, reversible steps: extract a seam, put the old module behind an interface and replace it piece by piece (the strangler fig pattern) rather than rewriting it all at once. Each step should be deployable and easy to roll back.
Fix the data as well as the code. After a bug that wrote bad records, write a query to find every affected row, correct them in a transaction or a reviewed script, and add a constraint or validation so the same bad state cannot be written again.

Follow-up

How do you debug a legacy system with no tests and no one who remembers why it works the way it does?
When would you rewrite a legacy module instead of refactoring it, and what risks would you weigh?
How do you confirm a fix in production when the bug happens once a week?

Suggested practice checklist

The plan follows the reported loop: introduction and background first, then the technical discussion topics, then the cultural meeting stories, ending in a full dry run.

Day 1 — Map the loop and inventory your projects

Write the three reported rounds (Initial Screen, Technical Assessment, Cultural Alignment Meeting) and one line on what each covers.
List four or five projects from your resume with your role, the language and database used, and the outcome.
Mark any project that involved legacy code, database work or non-engineering users, since those map to the reported topics.

Deliverable: A one-page loop map and a project inventory with the legacy, database and user-facing projects marked.

Day 2 — Self-introduction and past experience

Write a present, past, future introduction anchored on one concrete result, and say it aloud until it flows without notes.
Write a second version in plain language for a manager outside engineering.
Answer the past-experiences question aloud, choosing the projects that best match internal tooling work.

Deliverable: Two spoken versions of the introduction (technical and plain-language) and a written outline of the past-experiences answer.

Day 3 — Relate your background and walk through a hard problem

Write how your previous stack and systems relate to a company that runs internal tools for logistics and inventory work, naming overlaps and gaps honestly.
Outline your best technical challenge story as problem, options, decision, result and what you would change.
Record yourself telling it and cut anything that does not serve the decision.

Deliverable: A written background-to-role bridge and a one-page outline of the technical challenge story, plus a recording.

Day 4 — Debugging and maintaining legacy systems

Write your debugging sequence for a legacy production system, from reproducing the fault to adding a regression check.
Apply it to an example you choose: an inventory total in a database that disagrees with a physical count. List the first three things you would check and what each would rule out.

Deliverable: A one-page debugging checklist, the worked inventory-mismatch example and a spoken incident narration.

Day 5 — Integrating features into live workflows and protecting data

Outline a rollout for a new feature in an existing operational workflow: users, pilot, data migration, rollback and handover.

Deliverable: A written rollout outline, a worked backfill solution, a worked diff solution and a spoken deprecation message.

Day 6 — Cultural alignment stories

Write an ownership story from first request to deployment, with your own decisions marked.
Write a disagreement story with a team lead or another department that ends in a resolution based on evidence.
Write a story about feedback you received and what you changed afterwards, then list two questions about how engineers work with operations staff.

Deliverable: Three written story outlines (ownership, disagreement, feedback) and two questions to ask.

Day 7 — Full dry run

Run all three stages back to back aloud: introduction, past experience, technical challenge, legacy debugging, rollout, then the culture stories.
Have a friend play a non-technical manager for the technical answers and note every term they could not follow.
Revise the weakest two answers and rerun them.

Deliverable: A completed full mock, a list of jargon removed and two revised answers.

Background and working-style stories

Behavioral conversation is a large part of this loop. Candidates report background questions at the screen, project ownership, collaboration and disagreement handling in the culture meeting, and clear communication with non-technical staff throughout. Prepare stories where you made the decision and can state the outcome, and rehearse each in plain language.

What were your past experiences?
Tell me about a project you owned from the first request to deployment, and which decisions were yours.
Describe a disagreement with a team lead or another department and how it was resolved.
Tell me about feedback that changed how you work.
Describe a time you explained a technical decision to someone outside engineering.

Tell me about yourself.

Medium · Background and Experience

Approach

Use a present, past, future shape: what you do now, the two or three earlier pieces of work that led here, and why maintaining and extending internal tools for an industrial operation is the next step. Every sentence should move toward this role instead of replaying the resume in date order.
Anchor the answer on one concrete result, such as a system you kept running, a manual process you automated or a data problem you fixed. State it with its scale or outcome in one sentence that a manager outside engineering could repeat.
Name your language and database once in plain terms, then spend the words on what the software did for the people who used it. The role involves maintenance managers and operations leads, so the business effect matters more than a list of frameworks.
Close on fit: connect your experience to logistics, inventory or material-tracking style problems and to debugging existing systems. End on that reason so the answer does not trail off.
Keep it short enough to leave room for follow-ups. The mistake that sinks this answer is a chronological recital of every job that never says why you are in the room.

Follow-up

Which part of that background is most relevant to maintaining internal tools?
You mentioned that project: what did you personally build or decide, as opposed to the team?
Why this kind of operational software rather than a pure software product company?

Tell callers you do not own that their integration breaks

Medium · deprecation · compatibility · stakeholders

A field in a write endpoint's response must change shape. You own the endpoint; you do not own the four internal callers or the outbound webhook consumers who read it. Describe a deprecation you were responsible for: what you shipped first, how you established who was actually reading the field, the window you gave and what set its length, what you did about the consumer who never moved, and how you decided removal was safe. Name the signal you used, not the announcement you sent.

Approach

Establish the reader set empirically rather than from a wiki of owners: per-field usage counters keyed by principal, or access logs attributed to a consumer. State the blind spot of whichever you pick, since a consumer that reads the field only on a monthly job will not appear in a week of logs.
Ship additive first. Populate the new field alongside the old one so no reader is forced to move, which is also what keeps a rolling deploy safe, because old and new instances answer the same requests at the same time and a rollback must still find the old shape present.
Set the window from the slowest legitimate consumer's release cadence, not from your calendar, and decide separately what to do for a consumer with no release process at all, such as an external webhook endpoint you can only email.
Convert silence into evidence before you rely on it: a short, low-traffic removal window that makes a still-dependent consumer fail visibly and loudly while you are watching, rather than at three in the morning after you have moved on.

Follow-up

How would you detect a consumer that reads the field only during a monthly export?
One caller refuses to move and has a commercial relationship behind it. What changes in your plan and what does not?

Narrate an outage you owned from page to postmortem

Hard · incident response · blast radius · postmortems

Pick an incident you personally drove, ideally one where writes were affected rather than reads. In six to eight minutes: state the symptom as it first appeared on a dashboard, the blast radius you established before you knew the cause, the mitigation you applied and when, the mechanism you eventually proved, and the follow-up that would prevent a repeat. Bring numbers: error rate, tenants affected, minutes to mitigate, minutes to resolve. If you cannot name what you measured, choose a different incident.

Approach

Open on the signal rather than the cause: which metric at which percentile moved, on which service, at what time, so the listener follows the same evidence you had rather than a conclusion you already reached.
Separate mitigation from diagnosis out loud. State what you did to stop the bleeding (flag off, shed traffic, drain a lease, roll back a deploy) and say plainly that you did it before the mechanism was known, because those are two jobs with different deadlines.
Establish blast radius in countable terms: how many tenants, how many writes, and crucially whether the effect was loss or only delay. An append-only revision table or a pending outbox row means the change survived and the projection was merely behind, which is a repair rather than a data-loss incident.
Prove the mechanism instead of asserting it. Name the trace span that grew, the plan that flipped to a sequential scan, the lease that expired, plus one alternative you ruled out and the signal that stayed flat while you ruled it out.

Follow-up

What would you do differently in the first five minutes, given the same dashboard and no more information?
Which follow-up action did you deliberately not take, and why was dropping it the right call?