Interview guides · AdventHealth Tampa

AdventHealth Tampa Software Engineer Interview Guide

AdventHealth Tampa Software Engineer interview guide: ICD-10-CM/PCS coding questions, CDI scenarios, behavioral prompts and a 7-day prep plan.

The 60-second brief

AdventHealth Tampa is a healthcare organization, and candidates describe this role as part of its Clinical Documentation Improvement (CDI) team. The work reported is inpatient chart coding across more than one facility: reading clinical records, checking or assigning ICD-10-CM diagnosis codes and ICD-10-PCS procedure codes, working with clinicians so the record is complete, and flagging coding issues that could affect claims or compliance. The reported duties also include watching accounts that are discharged but not yet final coded so they are released on time.

This guide is for candidates interviewing for the Software Engineer opening at AdventHealth Tampa whose reported duties centre on inpatient coding and CDI collaboration. It covers the three reported rounds, the domain, problem-solving, behavioral and coding questions candidates report, and a plan that splits time between ICD-10 fluency, accuracy and timeliness workflows, a short algorithm or process-improvement story, and behavioral rehearsal.

Candidates report three rounds over roughly 3-5 weeks: an Initial Screening, one or more Technical Interviews on coding standards and real-world scenarios, and Behavioral Assessments on teamwork, communication and values.

Focus areas

Medical Coding (Inpatient)
ICD-10-CM Diagnosis Coding
ICD-10-PCS Procedure Coding

Overview

The job title says Software Engineer, but the duties candidates describe read like inpatient chart coding inside a CDI team: assign or verify diagnosis and procedure codes, work with coding colleagues on productivity and accuracy standards, raise issues that may affect claims processing or compliance, and keep discharged-not-final-coded accounts moving. The requirements candidates list are proficiency in ICD-10-CM/PCS, experience with electronic health record (EHR) systems, and analytical and problem-solving skills. Nice-to-haves are coding compliance knowledge, healthcare or coding experience, and familiarity with programming languages used in healthcare technology.

That mix shapes preparation. Reported topics are inpatient medical coding, ICD-10-CM diagnosis coding, ICD-10-PCS procedure coding, collaboration with CDI, and code timeliness tied to a two-day discharge requirement. You need to explain in plain words what each code set is for, how you keep assignments accurate, and how you balance accuracy against turnaround when many charts are waiting. Memorising code numbers is far less useful than being able to describe a repeatable workflow.

Candidates also report a small coding and algorithms group of questions, described as not the main focus. Prepare one real process or algorithm story from your own past work, with the input, the method, the result and what you would change. If you have no software story, a process-improvement story about a coding or documentation workflow can serve, as long as it has measurable before and after details.

Because the title and the duties do not obviously match, use the screening round to ask what a typical day contains and which tools you would use. Then weight your time: domain fluency and accuracy workflows first, behavioral stories second, and a light but real pass over coding questions third.

The AdventHealth Tampa interview process

Candidates describe three stages, from an Initial Screening through Technical Interviews to Behavioral Assessments, over roughly 3-5 weeks; the stages are what candidates report, not a published schedule.

Initial Screening

Candidates report that the process opens with an initial screening of basic qualifications and fit for the role. Treat it as the place to line your experience up against the listed requirements (ICD-10-CM/PCS proficiency, EHR experience, analytical skills) and to confirm what the day-to-day work is, since the title and the described duties differ.

What to demonstrate

Basic qualifications against the listed requirements
Fit for a role centred on inpatient coding and CDI collaboration
How clearly you describe your past coding, documentation or EHR work

How to prepare

Write a short walkthrough of your background that names your ICD-10 experience, the EHR systems you have used and one analytical result.
Prepare to say which part of your experience is software and which is coding or documentation, and ask which the role leans on.
Know the difference between ICD-10-CM diagnosis coding and ICD-10-PCS procedure coding well enough to explain each in a sentence.

Technical Interviews

Candidates report one or more technical interviews on coding standards and real-world scenarios. The reported question types here are domain questions (why ICD-10-CM/PCS matters, how accuracy is ensured, how you stay current, what tools you have used), problem-solving cases, and a small group of coding and process questions. Answer with workflows and examples rather than definitions alone.

What to demonstrate

Knowledge of ICD-10-CM/PCS and clinical documentation practice
How you structure an accuracy check on coded records
Ability to explain technical concepts clearly
Reasoning about process and algorithm choices when a coding question comes up

How to prepare

Outline an accuracy workflow: code against documentation, query the provider when the record is unclear, review a sample, and track errors by type.
List the tools you have used for coding and documentation, with one concrete task each.
Prepare a process-optimisation story with a measurable before and after, and be ready to describe the steps as an algorithm.
Rehearse the answer on keeping up with changes in coding regulations: name your habits and one change you applied.

Behavioral Assessments

Candidates report behavioral assessments on teamwork, communication and alignment with company values. The reported prompts cover collaborating toward a shared goal, handling feedback and what sustains a positive work culture, alongside problem-solving prompts such as deciding with incomplete information. Prepare stories with a clear personal role and an outcome.

What to demonstrate

Teamwork and collaboration examples
Communication with colleagues and clinicians
Response to feedback and to uncertainty
Stated alignment with the organisation's mission as candidates describe it

How to prepare

Write three stories in situation, task, action, result form, each with your own decision and a result you can state.
Choose one story that involves working with people outside your own function, since the role is described as working with healthcare professionals.
Prepare a one-sentence answer on what keeps a team's culture healthy, backed by something you did.
Practise saying what you would do differently in each story.

Where candidates lose points

Answering a 'coding' question as only software or only medical coding, so the story misses the role

Say which meaning you are using. Prepare one example that fits chart coding or documentation accuracy and one that fits software, and choose the one closer to the duties the recruiter confirms.

Naming ICD-10 without separating diagnosis coding (CM) from procedure coding (PCS)

Prepare a one-sentence description of each code set and one sentence on why accurate assignment matters downstream, for claims processing and for the clinical record.

Describing accuracy as 'I double-check my work'

Outline a concrete workflow: match every code to documentation, query the provider when it is unclear, review a sample, record errors by type, and act on the trend.

Talking only about accuracy and ignoring turnaround, although code timeliness and discharged-not-final-coded accounts are reported topics

Prepare a rule for ordering a queue, for example oldest accounts first, and explain what you do when a chart needs a provider query and cannot be completed immediately.

Giving behavioral answers in 'we' terms with no decision of your own and no result

For every story, write one sentence starting 'I decided' and one sentence with the outcome, ideally with a number or a clear before and after.

Questions & practice

How would you optimize a process for coding clinical records?

Medium · Coding / Algorithms

Approach

Measure before optimising. Break discharge-to-final-code time into stages (documentation complete, coder pickup, query out and back, review, final) and find the stage where accounts wait longest. It is often query turnaround or late documentation, not coding itself.
Trigger work from events instead of batch pulls. A discharge ADT event (A03) creates the coding task right away, and a separate signal for complete documentation keeps coders from opening charts they cannot finish yet.
Automate the deterministic checks. Hold the code set in a hash map keyed by code and effective date for O(1) validity lookups. Run pre-bill edits for invalid or non-billable codes, age and sex conflicts and missing POA indicators, so errors are caught before billing instead of after a denial.
Use assisted coding carefully. NLP or CAC suggestions can cut review time, but a coder confirms every code, and suggested and final codes are logged so the suggestion quality can be audited and over-coding risk monitored.
Cover the edge cases: late addenda after a code is final (re-code and re-bill path), accounts that span an October 1 code set change (version by discharge date), and duplicate or merged patient records. Track accuracy next to throughput so the speed-up is not paid for in denials.

Follow-up

Your change cut coding time but the denial rate went up. How do you find out why?
How would you design the system so coders never pick up an account that is still missing documentation?
What would you put on a dashboard for the coding manager, and what would you leave off?

Can you describe a coding algorithm that you have implemented in a previous role?

Medium · Coding / Algorithms

Approach

Pick one algorithm you wrote and can defend line by line. Explain the problem, the input shape and size, and why a simple approach was not enough.
Give the algorithm and its complexity in concrete terms. For example: a validator that checks the code format (letter, digit, alphanumeric, optional decimal with up to four more characters) and then a hash lookup against the versioned code table, O(1) per code. Note that a well-formed code is not necessarily billable at the highest specificity.
Explain the data structure choice from the access pattern. For example, a prefix tree or sorted list for hierarchy and category lookups by the first three characters, against a hash map for exact-match validation, with the memory cost of each.
Explain how you proved it worked: unit tests on boundary cases (codes missing a required 7th character, deleted codes, codes valid in one fiscal year but not the next), plus a run against real historical data before release.
Close with the result and one limitation you would fix now, such as moving from a nightly batch to per-event validation.

Follow-up

What is the worst-case input for your algorithm, and did it ever show up in production?
How would you change it if the data grew tenfold or stopped fitting in memory?
Which alternative did you reject, and why?

Archive a resource graph without breaking live references or recursing

Medium · graph traversal · topological order · tenant isolation

Resources reference other resources within a tenant; for the largest tenant the reference table holds up to 2,000,000 nodes and 8,000,000 edges. Archiving a resource must archive everything reachable from it that nothing outside the set still references, refuse when a live external referrer exists, and terminate when references form cycles, which they legitimately do. Produce the archive order and the refusal list, targeting O(V+E). Say what stops the traversal crossing a tenant boundary, and why recursion is the wrong control structure at this size.

Approach

Load the subgraph with the tenant predicate on both endpoints of the edge, not only on the side you started from. Scoping the left table alone is the classic cross-tenant leak: one mis-entered edge then pulls another tenant's resources into the traversal and, worse, into the archive.
Traverse iteratively with an explicit stack. A 2,000,000-node graph can hold a chain deep enough to exhaust a native stack in the low tens of thousands of frames, and that failure is a process crash rather than an error you can return.
Treat cycles as data rather than corruption: compute strongly connected components with Tarjan in O(V+E) using its own explicit stack, then condense. The condensation is a DAG, so a topological order over it gives the archive order, and every member of a component archives in one transaction because no order within a cycle is valid.
Decide refusals with reverse edges. A candidate is archivable only if every in-edge originates inside the candidate set, so build the transpose or count in-degrees restricted to the visited set, and emit each blocked resource with the id of the external referrer, which is the only part of the answer an operator can act on.

Follow-up

The graph is read in one query and the archive writes a minute later. What can change in between, and how do you make the write safe?
The candidate set is 400,000 resources. Is that one transaction, and if not, what does a half-finished archive look like to a reader?

Replace offset paging on the resource feed with keyset

Easy · keyset pagination · composite index · sort order

resource holds resource_id, tenant_id, owner_user_id, title, body_ref, version, status ('draft','active','archived','deleted'), created_at, updated_at, deleted_at, with an index on (tenant_id, status, updated_at DESC, resource_id DESC). The listing endpoint returns active resources for one tenant, newest update first, 50 per page, today with LIMIT 50 OFFSET n. Tenants reach page 400 and rows are created while they read. Write the keyset query, define what the cursor carries and how it is encoded, and say which part of the index each predicate uses. Assume PostgreSQL 16.

Approach

Name the two failures separately. OFFSET 20000 makes the server produce and discard 20,000 rows, so page cost grows with depth rather than with page size. Independently, any write that changes how many rows sort above the offset moves the window between two fetches, and the direction decides which anomaly you get: an insert lands at the head of updated_at DESC and pushes already-returned rows down past the boundary, so they are returned a second time; a delete above the offset, or a row whose updated_at is bumped above the cursor, pulls rows up and one is never returned at all. Nothing in the response reveals either.
Write the seek: WHERE tenant_id = $1 AND status = 'active' AND (updated_at, resource_id) < ($2, $3) ORDER BY updated_at DESC, resource_id DESC LIMIT 50. The row-value comparison is one index range rather than a disjunction, and both columns are NOT NULL, which is what makes that comparison well defined.
Map each predicate onto the index: tenant_id and status are equality on the leading columns, (updated_at, resource_id) is the range, and the ORDER BY matches the index order so no Sort node appears and the scan stops after 50 rows. The DESC in the definition only matters for mixed directions — a plain ascending btree on the same columns is read backwards for this query.
Put both sort columns in the cursor and nothing the client can tamper with into another tenant: base64 of (updated_at, resource_id), validated server-side, with tenant_id taken from the principal.

Follow-up

The client asks for 'jump to page 400'. What do you offer instead, and what does the honest version cost?
Sort order becomes user-selectable across four columns. How many indexes is that, and which would you refuse to add?

Find version gaps and relay lag with window functions

Medium · window functions · event tables · frame semantics

outbox_event holds event_id, aggregate_type, aggregate_id, aggregate_version, event_type, payload, status ('pending','published','dead'), attempts, created_at, published_at. A projection is missing rows and you must decide whether the relay skipped events or the consumer dropped them. Write three queries over the last seven days: one listing every aggregate_id whose published aggregate_version sequence has a hole, one giving per-day counts with a running total, and one returning the newest published event per aggregate. For each, say where the window function is evaluated relative to WHERE and LIMIT. PostgreSQL 16.

Approach

Gaps: compute lead(aggregate_version) OVER (PARTITION BY aggregate_id ORDER BY aggregate_version) in a subquery, then filter next_version <> aggregate_version + 1 in the outer query. Window functions are evaluated after WHERE, GROUP BY and HAVING and before the outer ORDER BY and LIMIT, so the predicate cannot sit in the same WHERE clause and PostgreSQL 16 has no QUALIFY.
Say what the seven-day filter does to the answer: it truncates every partition, so the first row per aggregate has no predecessor inside the window and a hole spanning the boundary is invisible. Widen the window, or join to resource.version as the authority for the true maximum.
Running total: SELECT date_trunc('day', created_at) AS d, count() AS n, sum(count()) OVER (ORDER BY date_trunc('day', created_at) ROWS UNBOUNDED PRECEDING). An aggregate inside a window call is legal because grouping runs before windowing. The grouping key is unique per row here so ROWS and RANGE agree, but write the frame anyway — over ungrouped rows with tied timestamps the default RANGE frame pulls in every peer row and the total jumps.
Newest per aggregate: DISTINCT ON (aggregate_id) ... ORDER BY aggregate_id, aggregate_version DESC is the cheap PostgreSQL-only form when an index matches that order; row_number() OVER (PARTITION BY aggregate_id ORDER BY aggregate_version DESC) = 1 is the portable form and needs a subquery for the same evaluation-order reason as the gap query.

Follow-up

Relay failover redelivers events. Does a duplicate break the gap query, and how would you detect one from this table alone?
Turn the gap check into a continuous monitor rather than a query someone runs after an incident. What does it watch?

What is the significance of ICD-10-CM/PCS coding in healthcare?

Medium · Technical / Domain Questions

Approach

Split the code set in two. ICD-10-CM codes diagnoses in every care setting in the United States. ICD-10-PCS codes procedures on inpatient hospital stays only; outpatient and physician procedures use CPT/HCPCS.
Give the structure. A CM code has 3 to 7 characters: a letter, a digit, an alphanumeric third character, then extensions for etiology, site, laterality and a 7th character such as A/D/S for injury encounters. A PCS code is always exactly 7 characters, each position a fixed axis (section, body system, root operation, body part, approach, device, qualifier), and it never uses the letters I or O.
Explain what the codes drive. On an inpatient claim, the principal diagnosis, secondary diagnoses flagged as CC or MCC, and the PCS procedures group the stay into an MS-DRG, which sets Medicare inpatient payment. One wrong principal diagnosis can move the whole DRG.
Name the uses beyond payment. Present-on-admission indicators separate hospital-acquired conditions, and the same codes feed quality measures, risk adjustment, public health reporting and research. Laterality and encounter detail give these uses more specificity than ICD-9 had.
For an engineering answer, point out that the code set is versioned. Updates take effect each October 1, and inpatient claims use the version in force on the discharge date, so any system has to store codes with their effective dates.

Follow-up

Walk me through how the 7 characters of a PCS code are built for one procedure you know.
Why is PCS used only for inpatient facility claims and not for outpatient visits?
How can a missed MCC change what the hospital is paid for a stay?

Can you explain the process of ensuring coding accuracy?

Medium · Technical / Domain Questions

Approach

Start from documentation. Read the whole record (H&P, progress notes, operative reports, discharge summary) and choose the principal diagnosis by the official rule: the condition that, after study, was chiefly responsible for the admission.
Look the term up in the Alphabetic Index, then always confirm it in the Tabular List, where the instructional notes live. Excludes1 means the two conditions are not coded together; Excludes2 means both may be coded if both are present. Code first and use additional code notes set the sequence.
Code to the highest specificity the record supports, with laterality, the 7th character and present-on-admission indicators. Do not code a condition from an abnormal lab value alone. If documentation is missing, conflicting or ambiguous, send the provider a compliant, non-leading query, which is where CDI comes in.
Run software checks before the claim goes out: the encoder and MS-DRG grouper, plus Medicare Code Editor edits for invalid codes, age or sex conflicts and unacceptable principal diagnoses. Make sure every CC or MCC that moves the DRG is supported in the record.
Close the loop with audits. Sample accounts before and after billing, give extra review to high-risk DRGs, track accuracy by code and by DRG change rate, and turn recurring errors into coder education or edit rules.

Follow-up

The lab shows a sodium of 128 but no provider documents hyponatremia. What do you do?
The encoder suggests a code that the documentation does not clearly support. How do you resolve it?
How would you measure accuracy across a team of coders without slowing the queue down?

How do you stay updated with changes in coding regulations?

Medium · Technical / Domain Questions

Approach

Name the update cycle. The ICD-10-CM and PCS code sets change every October 1, with some April 1 updates in recent years. Inpatient MS-DRG and CC/MCC changes come through the annual IPPS rulemaking. Say how you read the addenda (new, deleted and revised codes) before each effective date.
Name the guidance sources: the ICD-10-CM Official Guidelines for Coding and Reporting, the ICD-10-PCS guidelines, AHA Coding Clinic issued quarterly, and compliance material such as OIG work-plan items for inpatient coding.
Turn reading into practice. Keep a change log of the codes your service lines use most, rework a few charts under the new rules, and share the differences with the team before the effective date.
Mention any continuing education or credential upkeep (for example AHIMA or ACDIS credentials) only if you actually hold it. Describing a real routine counts for more than listing sources.
For the engineering side, explain how a system absorbs an update: load the new code tables with effective dates rather than overwriting the old ones, pick the version by discharge date, and regression-test edits and mappings against both versions.

Follow-up

Name one recent code or guideline change and explain how it changed the way you coded a chart.
An account discharged on September 30 is coded on October 3. Which code set version applies, and why?
How would you find out which open accounts an update affects?

What tools or technologies have you used for coding and documentation?

Medium · Technical / Domain Questions

Approach

Organise the answer by workflow stage, not as a list of brand names: the EHR where documentation is read, an encoder for code lookup and edits, an MS-DRG grouper, the provider query or CDI tool, and the abstracting or billing system the codes flow into. Candidates report EHR experience as a requirement.
For each tool, give one concrete thing you did with it. For example: built or used a work queue sorted by discharge date, read the grouper output to check that a CC or MCC was supported, or tracked query turnaround.
If you have used computer-assisted coding, explain the trade-off. NLP suggestions speed up chart review, but every suggested code still needs a coder to confirm it against the documentation, and over-coding risk has to be audited.
For a software answer, add the integration layer: HL7 v2 ADT messages (A03 is the discharge event) to trigger work, FHIR resources such as Condition, whose code.coding carries the ICD-10-CM system URI, and SQL reporting on discharged-not-final-coded accounts.
On documentation, mention how you recorded decisions: query templates, audit findings and a shared reference of local coding conventions. Show that someone else could follow your reasoning.

Follow-up

What did a tool you used get wrong, and how did you catch it?
How would you check that codes written to the EHR match what reaches the billing system?
If you had to pick between better encoder edits and faster chart navigation, which would you invest in and why?

Describe a challenging project you worked on. What was your approach to solving the issues encountered?

Medium · Problem-solving / Case Studies

Approach

Pick a project with a measurable problem and a constraint, such as a coding backlog against a discharge timeliness target, a mapping or interface that sent wrong codes downstream, or a migration between code set versions.
Describe the diagnosis before the fix: what you measured (backlog age, error rate, DRG change rate, failed records), how you found the root cause, and what you ruled out along the way.
Give two options you considered and the trade-off that decided between them, for example adding manual review (accuracy) versus automating an edit (throughput). Say why you chose one.
Give the result in numbers, plus what you would change now. Keep the focus on the decisions you made, not on what the team did.

Follow-up

What was the riskiest part of your change, and how did you limit the damage if it went wrong?
How did you confirm that your change caused the improvement and not something else?
Which stakeholder disagreed with the approach, and what changed their mind?

How would you prioritize tasks when faced with multiple coding assignments?

Medium · Problem-solving / Case Studies

Approach

State the objective and the constraints. Accounts must be coded accurately and in time to bill. Candidates report code timeliness against a two-day discharge requirement as a topic, so days since discharge is the first sort key.
Rank the work. Sort by deadline first, then break ties by impact (expected DRG weight or dollar value, payer filing limits). Earliest deadline first minimises the maximum lateness on a single queue, and a min-heap on (deadline, -value) gives O(log n) inserts and pops.
Handle blocked work separately. Accounts waiting on a provider query or missing documentation go to a hold list with a follow-up date, so they do not stall the queue, and each one is escalated before it breaks the timeliness target.
Protect accuracy under pressure. Do not speed up high-risk DRGs to clear volume. Route complex cases (long stays, many procedures, high-risk principal diagnoses) to more experienced coders, and send a time-boxed second review to whatever the deadline order pushes forward.
Report the trade-off: show the age of the discharged-not-final-coded backlog every day, and raise capacity problems early instead of quietly missing targets.

Follow-up

Two accounts hit the deadline at the same time: one is high value and awaiting a query, the other is simple and ready. What do you do?
How would the ranking change if a payer's filing deadline is closer than the internal target?
What metric would tell you the prioritisation is hurting accuracy?

One log partition stops advancing while the others drain

Easy · poison message · head-of-line blocking · consumer lag

Search results for a subset of tenants are hours stale; the rest are current. The projection consumer reports lag of zero on 15 of 16 partitions and 400,000 on one. Its error rate is flat and its CPU is idle. outbox_event has no pending rows older than a second, so the relay has published everything it holds. Identify the mechanism, give the ordered checks, and state what you do in the first ten minutes versus what you change permanently.

Approach

Read the lag distribution first. A slow consumer lags everywhere; zero on fifteen partitions and 400,000 on one is not throughput. Idle CPU on the stuck partition means the consumer is not advancing its offset at all, which points at one message it cannot get past rather than at a rate problem.
Exonerate the producer before touching the consumer. No pending outbox rows older than a second means the relay published, so the event exists in the log. This separates never sent from sent and never applied, which are different code paths and usually different owners.
Read the message at the stuck offset and the handler's log lines for its event_id. A flat error rate with no progress has two explanations and you must distinguish them: the handler is throwing and the retry loop is swallowing it, or the handler is blocking on something and never returning. Idle CPU with no error lines favours the second.
Mitigate before diagnosing further. Move the offending event to a dead-letter store and commit the offset past it. Adding consumers does nothing here, because a partition is consumed by exactly one member of the group, and the blast radius is every aggregate hashed to that partition, not only the aggregate that produced the bad event.

Follow-up

The dead-lettered event carried aggregate_version 7 and the projection had applied 6. What must the replay do differently if 8 and 9 landed in the meantime?
How do you show staleness to the user while the partition is behind, given the API already returns the projection's watermark?

Suggested practice checklist

The plan follows the three reported rounds: day 1 fixes the role picture, days 2 to 5 cover the technical stage (ICD-10 fundamentals, accuracy, tools, process and algorithm stories), and days 6 and 7 turn problem-solving and behavioral prompts into rehearsed stories.

Day 1 — Pin down the role and the screening pitch

List the requirements candidates describe (ICD-10-CM/PCS, EHR experience, analytical skills) and write one piece of evidence from your own work for each.
Write a short background walkthrough and a list of questions to confirm the day-to-day work with the recruiter.

Deliverable: A one-page requirements-to-evidence table and a written screening pitch with your questions for the recruiter.

Day 2 — ICD-10-CM and ICD-10-PCS foundations

Write a plain-language explanation of diagnosis coding versus procedure coding and why accurate code assignment matters.
Say your explanation aloud as the answer to the significance question, then trim it so it stands alone.

Deliverable: A written and a spoken answer to the ICD-10-CM/PCS significance question, each with an example of a chart and the codes it needs.

Day 3 — Accuracy workflow and staying current

Outline an accuracy process: code against documentation, query the provider, sample review, error tracking.
Write down how you follow code-set and regulation updates and one change you applied in your work.
Answer both questions aloud and cut any claim you cannot back with an example.

Deliverable: A one-page accuracy checklist plus rehearsed answers to the accuracy and regulation-updates questions.

Day 4 — Tools, prioritisation and process improvement

List the coding, documentation and EHR tools you have used and one task you completed in each.
Write a rule for ordering a queue of charts that balances accuracy and timeliness, covering discharged accounts not yet final coded.
Outline a process-improvement answer: measure the current process, find the bottleneck, change one thing, verify the result.

Deliverable: A tools inventory, a queue-ordering rule and a four-step process-optimisation outline.

Day 5 — Algorithm story and a coding warm-up

Pick one algorithm or automation you built and write its input, steps, complexity and result.
Work through the reviewed practice exercise on archiving a resource graph without recursion, and note the data structure you chose and why.

Deliverable: A one-page algorithm story and a working solution to the practice exercise with its time and space complexity noted.

Day 6 — Problem-solving and troubleshooting stories

Write a challenging-project story covering the issue, your approach and the result.
Write a troubleshooting story with your diagnostic sequence, the fix and the prevention step.
Write a decision-with-incomplete-information story that states your assumption and how you checked it.

Deliverable: Three written stories in situation, task, action, result form, each with a personal decision and an outcome.

Day 7 — Behavioral rehearsal

Prepare answers on collaboration, handling feedback and positive work culture, using real examples.
Run all prepared stories aloud once, cutting any sentence that has no personal action or result.
Write your closing questions about the team, the tools and the next steps.

Deliverable: Spoken run-throughs of the three behavioral answers and a list of questions to ask.

Behavioral stories for a coding and CDI team

Candidates report that the final stage covers teamwork, communication and alignment with the organisation's mission, and that the role works with healthcare professionals and coding colleagues. Prepare stories that show your own decisions, how you worked across functions and what you did with feedback.

Describe a challenging project you worked on. What was your approach to solving the issues encountered?

Describe a time when you had to troubleshoot a coding-related issue.

Medium · Technical / Domain Questions

Approach

Choose a story that fits the role: either a software bug or a coding-accuracy problem such as a code assignment that did not match the documentation. Say at the start which kind it is, since 'coding' can mean either.
Set the situation in two sentences, then spend the time on your diagnostic sequence: how you reproduced or isolated the issue, which evidence you collected (logs, the source record, a sample of affected cases), and which hypotheses you ruled out.
State the fix and how you confirmed it worked: a re-run, a re-review of the affected records, or a before and after error count.
Close with prevention: a check, a test, a checklist item or a documentation query step so the same issue is caught earlier next time.
The mistake that sinks it is describing a team effort in 'we' terms without saying what you personally found and decided.

Follow-up

How did you know the root cause was the one you fixed and not a symptom?
What did you change so it would not recur?
What would you do differently if you met the same problem again?

Give an example of a time when you had to make a decision with incomplete information.

Medium · Problem-solving / Case Studies

Approach

Pick a decision where information really was missing and time or a deadline prevented waiting. Say what you knew, what you did not, and why the gap could not be closed quickly.
Show how you reduced the uncertainty cheaply: asked the one person who could answer, checked a sample, or chose the option that was easiest to reverse. In a coding setting, an example is querying a provider about unclear documentation instead of assuming a diagnosis.
State your decision rule and the assumption you wrote down, then say who you told so others could challenge it.
Give the outcome, including any part that turned out wrong and how you corrected it. A story where everything went right sounds unreal.
The mistake is to claim you waited for certainty, or to describe a guess with no reasoning behind it.

Follow-up

What was the cost of being wrong, and how did that shape your choice?
Which piece of missing information would have changed your decision?
How did you check your assumption afterwards?

Describe a situation where you had to collaborate with others to achieve a common goal.

Medium · Behavioral / Leadership

Approach

Choose an example with at least two groups whose priorities differed, such as clinicians and coders, or developers and operations. This matches the described duty of working with healthcare professionals.
Name the shared goal and your own role in it in one sentence each, then describe the specific actions you took: setting up a regular check-in, translating terms between groups, splitting the work, or documenting an agreement.
Describe one point of friction and how you resolved it with facts, such as a sample of records or a shared checklist, rather than by escalating.
End with a result both sides would accept: fewer queries, faster releases, fewer rework loops, or a shipped feature.
The mistake is a story in which the team succeeds and your contribution cannot be pointed to.

Follow-up

What did the other group need from you that you had not expected?
How did you handle a teammate who was not delivering?
What would you change about how that group communicated?

How do you handle feedback from peers or supervisors?

Medium · Behavioral / Leadership

Approach

Open with a direct statement of how you take feedback: you listen for the specific behaviour, restate it to confirm, and ask for an example before reacting.
Back it with one real case, such as a code review comment, an audit finding or a supervisor's note about your documentation, and say exactly what the feedback was.
Describe what you changed afterwards and how you checked it stuck, for example a changed checklist, a repeated review a few weeks later, or a drop in the same error.
Include a short example of giving feedback to a peer too, because the prompt covers both peers and supervisors.
The mistake is naming a trivial or flattering piece of feedback, or sounding defensive about the substance.

Follow-up

Tell me about feedback you disagreed with and what you did.
How do you give feedback to a peer who is more senior than you?
What feedback are you working on right now?

What do you believe is the most important aspect of maintaining a positive work culture?

Medium · Behavioral / Leadership

Approach

This asks for an opinion, so commit to one aspect: for example open communication about errors, clear shared standards, or mutual support when workloads spike. Say why it ranks first.
Define it in observable behaviours rather than a slogan, such as reporting your own mistakes early, sharing how you reached a decision, or covering for a colleague on a deadline.
Prove it with something you did in a previous team and a result that followed.
Link it to the work in this role as candidates describe it: colleagues who share productivity and accuracy standards and need quick, honest handoffs with clinicians.
The mistake is a list of virtues with no behaviour, no example and no connection to the job.

Follow-up

What did you do when the culture on a team was not what you described?
How do you keep that aspect going when the team is under time pressure?
How would you raise a concern about a colleague's work respectfully?