The reported questions fall into five groups. Technical fundamentals cover the software development lifecycle, object-oriented principles, debugging a complex application and cloud experience. Design questions cover a patient-records system, microservices against a monolith, security for healthcare applications, scaling under growing demand and integrating several systems. Problem-solving cases cover a late project, a dataset with missing values, a slow application, a feature with thin specifications and judging whether an implementation succeeded. Coding covers reversing a linked list, binary search, sorting integers and explaining complexity. A behavioral group covers challenges, prioritising, teamwork, persuasion and conflict.
The stack candidates describe is mainstream and broad rather than exotic: Java, C# or Python, frameworks such as Spring or .NET, and AWS or Azure. Cloud experience and security practice are listed as must-haves, while healthcare-systems knowledge, agile experience and familiarity with data analytics tools are listed as nice-to-haves. Prepare in the language you code in best, and be ready to describe one real cloud project in concrete terms: what ran where, how it was secured and how it was deployed.
Because the design questions are set in healthcare, security is not an afterthought you add at the end. When you design the patient-records system, put access control, audit logging, encryption in transit and at rest, and data retention into the first sketch, then discuss storage and scaling. The same habit helps with the microservices question, where service boundaries and the cost of distributed failures matter as much as team autonomy.
The loop also includes behavioral assessment and a conversation about fit, and the usual advice from candidates is to structure stories with Situation, Task, Action and Result. Build a small bank of real stories that each answer several prompts: a hard project, a tight prioritisation, a disagreement, a persuasion, a quick learning curve and a performance fix. Practise them aloud so that each one names your own decision and its measurable result.
Phone Screen
reportedCandidates describe the Phone Screen as an initial conversation about your background and how well you fit the role. No specific questions are tied to it, so use it to show that your experience lines up with the stack candidates describe for this role: Java, C# or Python, a cloud platform, and software design practice. Aim for a clear career narrative, one concrete cloud or backend project you can discuss in detail, and an honest reason for wanting to work on healthcare software.
What to demonstrate
- How your background maps to a Software Engineer role
- Whether your experience lines up with the languages and cloud platforms the role lists
- How clearly you can describe your own past work
How to prepare
- Write a short career narrative that ends on why healthcare programs and this role, and rehearse it aloud until it sounds natural.
- Pick one project and prepare to describe its architecture, your part in it and the cloud services it used, since cloud experience is a reported must-have.
- List your languages and frameworks (Java, C#, Python, Spring, .NET) and mark which you can discuss with depth versus which you have only touched.
Technical Assessment
reportedCandidates describe the Technical Assessment as an evaluation through coding questions and problem-solving exercises. The coding questions reported for this company are classic ones: reversing a linked list, binary search, sorting integers and explaining the complexity of what you wrote. The problem-solving questions reported are practical ones: debugging a complex application, optimising a slow application, cleaning a dataset with missing values, and starting a feature with limited specifications. Practise writing correct code in your best language and narrating your reasoning as you go.
What to demonstrate
- Working code in a language of your choice
- Handling of edge cases such as empty input and single elements
- Ability to state and justify time and space complexity
- A structured approach to debugging, optimising and cleaning data
How to prepare
- Write iterative and recursive linked-list reversal, a binary search and a sort from memory, each with tests for empty, single-element and duplicate-heavy input.
- Rehearse a debugging sequence out loud: reproduce, narrow the scope, read logs and recent changes, form a hypothesis, test it, fix, add a regression test.
- Outline how you would profile and speed up a slow application, naming the measurement you would take before changing any code.
- Prepare a missing-values routine: quantify and locate the gaps, decide whether they are random, then drop, impute or flag with a reason.
In-Person Interviews
reportedCandidates describe the In-Person Interviews as structured conversations covering technical skills, behavioral assessment and cultural fit. This is the stage where the design questions and the behavioral prompts fit best: the patient-records system, microservices against a monolith, security in healthcare applications, scaling for more users, integrating multiple systems, plus stories about challenges, deadlines, teamwork, persuasion and conflict. Prepare design answers that start from requirements and security, and stories that name your own decisions.
What to demonstrate
- Technical judgement across design, security and cloud topics
- Behavioral evidence from past projects, teamwork and conflict
- Fit with a team-oriented way of working, including code review and cross-functional collaboration
How to prepare
- Sketch the patient-records design end to end: data model, API, authentication and authorisation, audit trail, encryption, storage, scaling and failure handling.
- Prepare a balanced microservices-versus-monolith answer with a clear recommendation for a stated team size and workload.
- Build six to eight STAR stories covering a hard project, tight deadlines, teamwork, persuasion, conflict, quick learning and a performance fix.
- Prepare a spoken account of a project where you integrated several systems, including what failed and what you changed.
PracHub editorial advice for the preparation topics above.
Designing the patient-records system as plain storage and adding security in the last minute
Open the design with who may read and write which records, then place authentication, role-based authorisation, an audit trail and encryption at rest and in transit in the first diagram. Only then discuss the data model, indexing and scaling.
Reversing the linked list or writing the binary search without testing the edges
Run your code against an empty list, a single node, two nodes, and for binary search a target that is missing, first or last. State the complexity aloud: linear time and constant extra space for the iterative reversal, logarithmic time for the search, and watch the midpoint and loop bounds.
Giving a cloud answer that is a list of service names with no project behind it
Tell one workload story: what it did, what you owned, why you picked each service, how it was secured and deployed, and one thing that went wrong. Name only platforms you have really used.
Jumping to a fix in the debugging and slow-application questions without measuring or reproducing
Say the sequence first: reproduce, check recent changes and logs, narrow with a bisect or a profile, change one thing, and confirm with a test or a measurement. For performance, name the metric you would capture before and after.
Telling behavioral stories in which the team did everything and your own decision never appears
For each story write down the single decision you made, the alternative you rejected and the measurable result. Rehearse using first person for your actions, and keep one honest mistake and lesson per story.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
Write a function to reverse a linked list.
Write a function to reverse a linked list.
Approach
- Iterative three-pointer reversal: prev = null, curr = head; while curr is not null: next = curr.next, curr.next = prev, prev = curr, curr = next; return prev. O(n) time and O(1) extra space.
- Recursive version: reverse the rest of the list, then head.next.next = head and head.next = null; still O(n) time but O(n) call-stack space, and in Python the default recursion limit (about 1000) breaks it on long lists.
- Edge cases: empty list, a single node, two nodes; make sure the original head ends with next = null so the result has no cycle.
- Test with a helper that builds a list from an array and converts it back, checking [], [1], [1,2] and [1,2,3,4,5].
- Mention the variants: a doubly linked list (swap prev and next on each node), reversing positions m to n, and reversing in groups of k.
Follow-up
- Reverse only the nodes between positions m and n in one pass.
- Reverse the list in groups of k, leaving a final short group unchanged.
- How would you check that the list has no cycle before reversing it (Floyd's slow and fast pointers)?
How would you implement a binary search algorithm?
How would you implement a binary search algorithm?
Approach
- State the precondition: the data is sorted and supports random access. Iterative form: lo = 0, hi = n - 1; while lo <= hi: mid = lo + (hi - lo) / 2; return mid on a match, else move lo = mid + 1 or hi = mid - 1; return -1. O(log n) time, O(1) space.
- Explain why mid is lo + (hi - lo) / 2: (lo + hi) / 2 can overflow a 32-bit int in Java or C# for very large arrays; Python integers do not overflow.
- Pick one invariant and keep it consistent: closed interval [lo, hi] uses lo <= hi and hi = mid - 1; half-open [lo, hi) uses lo < hi and hi = mid. Mixing them causes off-by-one errors or infinite loops.
- Handle duplicates with lower-bound and upper-bound variants (first index >= target, first index > target). Know the libraries: Python bisect_left / bisect_right; Java Arrays.binarySearch returns -(insertion point) - 1 when the key is absent and does not guarantee which duplicate it finds.
- Test empty input, one element, a target below the minimum and above the maximum, and runs of duplicates; mention binary search on the answer over any monotonic predicate.
Follow-up
- Find the first and last occurrence of a target in a sorted array with duplicates.
- Search for a target in a sorted array that has been rotated at an unknown pivot.
- Compute the integer square root of x without a math library.
Solve a problem involving sorting an array of integers.
Solve a problem involving sorting an array of integers.
Approach
- Clarify constraints first: array size, value range, whether it must be in place, whether stability matters, and whether the built-in sort is allowed. Python's sorted() is Timsort (stable, O(n log n) worst case, O(n) on already sorted input); Java's Arrays.sort on int[] is a dual-pivot quicksort, while object sorts use stable TimSort.
- Know the comparison sorts and their deciding properties: merge sort is O(n log n) worst case, stable, O(n) extra memory; quicksort averages O(n log n) in place but is O(n^2) in the worst case and unstable; heapsort is O(n log n) worst case with O(1) extra memory but unstable; insertion sort is O(n^2) yet fast on small or nearly sorted input.
- When values are bounded, beat n log n: counting sort runs in O(n + k) for a value range of k (offset negatives first); radix sort runs in O(d(n + b)) for d digits in base b.
- Recognise common sorting problems: sort an array of 0s, 1s and 2s with the Dutch national flag (one pass, three pointers, O(1) space); squares of a sorted array with two pointers in O(n); kth largest with a size-k min-heap in O(n log k) or quickselect in O(n) on average.
- Cover edge cases: empty array, all equal values, negatives, already sorted or reverse-sorted input (which makes first-element-pivot quicksort quadratic).
Follow-up
- How would you sort data that does not fit in memory (external merge sort: sort chunks, then a k-way merge with a heap)?
- Why can no comparison sort beat Omega(n log n) in the worst case?
- How do you protect quicksort against adversarial or already sorted input?
Explain the time complexity of your solution to a coding problem.
Explain the time complexity of your solution to a coding problem.
Approach
- Count the dominant operations as a function of the input size, drop constants and lower-order terms, and name every variable separately (O(n + m), not O(n), when there are two inputs).
- Read the shape of the code: a single pass is O(n), nested loops over the same input O(n^2), halving the range each step O(log n), sorting O(n log n); hash map lookups are O(1) on average but O(n) in the worst case.
- For recursion, write the recurrence: T(n) = 2T(n/2) + O(n) gives O(n log n) by the master theorem; naive recursive Fibonacci is exponential (about O(1.618^n)) and becomes O(n) with memoisation.
- State space separately from time: auxiliary memory versus the input itself, and recursion depth on the call stack.
- Point out hidden costs and amortised cases: appending to a dynamic array is O(1) amortised because of capacity doubling; repeated string concatenation in a loop can be O(n^2) (use StringBuilder or join); Python slicing copies; 'in' on a list is O(n) but O(1) on average for a set.
Follow-up
- Explain amortised analysis with the dynamic array example.
- You have an O(n log n) solution and an O(n) solution. When would you still choose the first?
- What happens to your solution's time and space if the input arrives as an unbounded stream?
Hold a per-tenant active cap against concurrent creates
A tenant on the standard plan may hold at most 50 resources with status='active'. The create handler runs SELECT count(*) FROM resource WHERE tenant_id = $1 AND status = 'active', compares to 50, then inserts. Two creates arrive 3 ms apart on different instances and the tenant lands at 51. Name the anomaly, say whether PostgreSQL 16 READ COMMITTED or REPEATABLE READ prevents it and why, then give an implementation that holds the cap at READ COMMITTED with the exact statements. Finally, say what changes when the cap is 'at most one running export per tenant' on job_run.
Approach
- Name it: write skew. The two transactions read an overlapping set and write disjoint rows, so there is no row-level conflict for the engine to detect and each commit is individually legal.
- Rule out the levels precisely. READ COMMITTED takes a fresh snapshot per statement and takes no lock on the counted rows, so both see 49. PostgreSQL's REPEATABLE READ is snapshot isolation: it removes non-repeatable reads and phantoms within the snapshot but still admits write skew, because the anomaly is not a re-read of a changed row, it is a read of a set that a concurrent transaction invalidates. Only SERIALIZABLE closes it, by tracking the read dependency and aborting one transaction with SQLSTATE 40001 — a guarantee that exists only if the application re-runs the whole transaction from the read.
- Convert the set predicate into a single-row conflict: keep tenant.active_resource_count and run UPDATE tenant SET active_resource_count = active_resource_count + 1 WHERE tenant_id = $1 AND active_resource_count < 50 in the same transaction as the INSERT. Zero affected rows is the cap, returned as 409. The row lock serialises the decision at any isolation level, and contention is bounded to one tenant's row — which is also the fair-scheduling unit, unlike a global counter that would convoy every tenant behind one row.
- State the cost you just took on: a counter is a second source of truth that can drift, so every path that changes status must adjust it inside the same transaction, and a periodic reconciliation has to exist, with resource_revision as the authority for what the count should have been.
Follow-up
- A resource moves from archived back to active. Which statements change, and what breaks if the counter update and the status change land in different transactions?
- The cap becomes plan-dependent and a plan can change mid-month. Where does the number 50 live, and who reads it?
Find version gaps and relay lag with window functions
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?
Explain the software development lifecycle.
Explain the software development lifecycle.
Approach
- Name the phases and the artifact each one produces: requirements (user stories or a requirements spec), design (architecture and data model), implementation (reviewed code), testing (unit, integration, acceptance results), deployment (a release), maintenance (fixes and monitoring that feed back into new requirements).
- Contrast the models by how they handle change: waterfall runs phases in sequence with sign-off gates, so a late requirement change is expensive; the V-model pairs each design level with a test level; iterative and agile models repeat the whole cycle in short increments and ship working software each time.
- Tie it to daily practice: pull requests with code review, CI running tests on every merge, a staging environment, automated deployment, and production monitoring whose alerts and user feedback become the next iteration's backlog.
- Explain why order matters: a defect found in requirements or design is cheaper to fix than the same defect found after release, which is the argument for early reviews and tests written alongside the code.
- Close with one feature you shipped, traced through every phase, including one thing that went wrong in testing or maintenance and what you changed in the process afterwards.
Follow-up
- When would you pick a sequential model over an agile one, for example with fixed regulatory requirements or a fixed-scope contract?
- Where does security belong in the lifecycle (threat modelling at design, static analysis and dependency scanning in CI, penetration testing before release)?
- How do you handle a requirement that changes in the middle of an iteration?
What are the key principles of object-oriented programming?
What are the key principles of object-oriented programming?
Approach
- Give the four principles with a one-line definition each: encapsulation (state hidden behind methods that protect invariants), abstraction (callers depend on what an object does, not how), inheritance (a subclass reuses and specialises a parent type), polymorphism (one call resolves to different implementations at runtime through dynamic dispatch).
- Show them in one small example in Java, C# or Python: an abstract Notification type with a send() method, EmailNotification and SmsNotification overriding it, and a caller that loops over a list of Notification without knowing the concrete class.
- Discuss the trade-off: prefer composition over inheritance when the relationship is has-a or when behaviour must change at runtime; deep hierarchies create fragile base classes, and the Liskov substitution principle (a Square subclass of Rectangle breaking setWidth) is the standard counterexample.
- Mention the language differences: Java and C# allow single class inheritance plus multiple interfaces; Python allows multiple inheritance resolved by the C3 method resolution order, relies on duck typing, and has no enforced private members (a leading underscore is a convention, double underscore triggers name mangling).
- Connect to SOLID briefly, especially single responsibility and dependency inversion, since they are how the principles show up in reviewable code.
Follow-up
- What is the difference between an abstract class and an interface in Java or C#, given that both now allow default method implementations?
- Give an example where inheritance made a codebase harder to change, and how you would refactor it.
- Is method overloading polymorphism, and how does it differ from overriding (compile-time versus runtime binding)?
How would you design a system for managing patient records?
How would you design a system for managing patient records?
Approach
- Scope the actors and operations: patients, clinicians, administrators and auditors; create, read, amend and search records, attach documents. Then the non-functional needs: confidentiality, integrity, availability, auditability and long retention.
- Data model: a relational database for the core entities (patient, encounter, diagnosis, medication, allergy) with ACID transactions; documents and images in object storage with a metadata row; amendments appended as new versions instead of overwriting, so history is preserved.
- Access control: SSO with MFA for authentication; role-based plus attribute-based authorization (a clinician can read a record only with a care relationship); an emergency break-glass path that is logged and reviewed; every read and write recorded in an append-only audit log.
- Protection and interoperability: TLS in transit, encryption at rest with managed keys, field-level encryption for identifiers such as SSN; a REST API behind a gateway, and a standard such as HL7 FHIR (Patient, Observation, Encounter resources) when records are exchanged with outside systems.
- Scale and reliability: the workload is read-heavy, so add read replicas and careful caching (no patient data in shared caches without access checks); optimistic locking with a version column for concurrent edits; backups with point-in-time recovery and multi-zone deployment.
Follow-up
- Two clinicians edit the same record at the same moment. What does your system do?
- How would you detect and merge duplicate records for the same patient created at different sites?
- A patient asks for a list of everyone who viewed their record. How does your design answer that?
Discuss the trade-offs between microservices and monolithic architecture.
Discuss the trade-offs between microservices and monolithic architecture.
Approach
- Monolith strengths: one deployable, in-process calls, one database with real ACID transactions, simple local debugging and a single pipeline. Costs: every change redeploys everything, the whole app scales as one unit, and module boundaries erode without discipline.
- Microservices strengths: independent deployment and scaling per service, fault isolation, teams owning a service end to end, freedom to choose a stack per service. Costs: network latency and partial failure, no cross-service transactions (sagas and eventual consistency), duplicated data, and heavy operational load (service discovery, tracing, per-service CI/CD).
- Decide on concrete factors: number of teams, how clear the domain boundaries are, whether parts have very different scaling or release needs, and whether the team can run distributed operations. A modular monolith is the common middle path.
- Name the anti-pattern: a distributed monolith, where services share one database or must deploy in lockstep, which pays the costs of both styles and gets the benefits of neither.
- For migration, describe the strangler fig pattern: route one bounded capability at a time to a new service behind a facade, starting with the part that has the clearest boundary or the most distinct scaling need.
Follow-up
- An operation updates data owned by two services. How do you keep them consistent (saga with compensating actions, transactional outbox)?
- Which part of an existing monolith would you extract first, and why?
- How do you debug one request that crosses five services?
What considerations would you make for system security in healthcare applications?
What considerations would you make for system security in healthcare applications?
Approach
- Start with a threat model: list assets (patient health information, credentials, audit logs), actors (external attackers, malicious or careless insiders, compromised vendors) and entry points, then walk STRIDE (spoofing, tampering, repudiation, information disclosure, denial of service, elevation of privilege).
- Identity and access: MFA, least privilege, role- and attribute-based authorization, short-lived tokens, service-to-service authentication (mTLS or cloud IAM roles), and an audited break-glass path for emergencies.
- Data protection: TLS for every hop, encryption at rest with managed keys and rotation, data minimisation, de-identified copies for analytics, and no patient data in logs, URLs or error messages.
- Application security: the OWASP Top 10 basics (parameterised queries against injection, output encoding against XSS, CSRF tokens, server-side input validation), secrets in a vault rather than code, and SAST, dependency scanning and DAST in the CI pipeline.
- Operations and compliance: immutable audit logs with alerting on unusual access, tested backups, an incident response plan, and familiarity with the HIPAA Security Rule's administrative, physical and technical safeguards; for federal information systems in general, FISMA with NIST SP 800-53 controls is the common reference.
Follow-up
- How would you give analysts useful data without exposing patient identity (HIPAA Safe Harbor removes 18 identifier types; expert determination is the alternative)?
- How would you detect an employee browsing records they have no reason to see?
- What do you do in the first hour after a suspected data breach?
How would you approach scaling an application to handle increased user demand?
How would you approach scaling an application to handle increased user demand?
Approach
- Measure before changing anything: find the saturated resource (CPU, memory, database connections, a downstream API) from p95/p99 latency, error rates and utilisation, and load-test to find where the system breaks.
- Make the app tier stateless (sessions in a shared store such as Redis, or signed tokens) so it scales horizontally behind a load balancer, with autoscaling on CPU or request rate.
- Relieve the database in order of cost: fix slow queries and add indexes, use connection pooling, add read replicas for read-heavy traffic, cache hot reads with cache-aside and TTLs, and partition or shard only when a single primary can no longer take the writes.
- Move slow work off the request path with a queue and workers (reports, emails, file processing), serve static assets from a CDN, and add rate limiting, timeouts and graceful degradation so overload sheds load instead of cascading.
- State the trade-offs: vertical scaling is simple but has a ceiling, caching and replicas introduce stale reads, and every layer adds cost and operational work.
Follow-up
- Traffic is predictable and spikes around a known deadline day. How do you prepare?
- After adding read replicas, a user saves a change and does not see it on refresh. Why, and how do you fix it (read-your-writes routing to the primary)?
- How do you invalidate cached data when the underlying record changes?
Describe a project where you had to integrate multiple systems.
Describe a project where you had to integrate multiple systems.
Approach
- Set up the story with the systems involved, the data that moved between them, the direction of each flow and your own role in it, in a few sentences.
- Explain the integration style you chose and why: synchronous REST or SOAP calls when the caller needs an immediate answer, asynchronous messaging (queues or pub/sub) to decouple availability, or scheduled batch files and ETL when latency is acceptable and volumes are large.
- Describe the data contract: a canonical schema or explicit field mapping, identifier mapping between systems, validation at the boundary, and versioning so one side can change without breaking the other.
- Cover failure handling: timeouts, retries with exponential backoff and jitter, idempotency keys so a retry cannot apply twice, a dead-letter queue for poison messages, a circuit breaker for a failing dependency, and a reconciliation job comparing record counts or checksums.
- End with a measurable result and how you monitored it (contract tests, alerts on queue depth or error rate), plus one thing you would design differently.
Follow-up
- How did you test against a system your team did not control?
- The downstream system was down for several hours. What happened to the data in the meantime?
- The other team changed a field format without notice. How did you find out, and how did you protect against it afterwards?
How would you approach a situation where a project is falling behind schedule?
How would you approach a situation where a project is falling behind schedule?
Approach
- Quantify the gap first: remaining work against measured velocity or the burndown, and the date that trend actually predicts, rather than a feeling of being late.
- Find the cause, because the fix depends on it: scope creep, underestimated tasks, a blocked dependency on another team, lost staff, or unplanned production support.
- Lay out the levers with their costs: cut or defer scope by priority (MoSCoW), re-sequence to deliver the highest-value slice first, remove blockers by escalating, or add people, noting Brooks's law that new people on a late project often slow it further at first.
- Tell stakeholders early with options and their trade-offs (a smaller release on the date, or the full scope at a later date), and do not quietly cut testing, security review or documentation to recover time.
- Prevent a repeat: shorter milestones, a visible risk list, and a retrospective on where the estimate went wrong.
Follow-up
- The stakeholder refuses both a scope cut and a date change. What do you do?
- How do you tell an estimation problem from an execution problem?
- When does adding engineers to a late project actually help?
You are given a dataset with missing values. What steps would you take to clean the data?
You are given a dataset with missing values. What steps would you take to clean the data?
Approach
- Profile before changing anything: count missing values per column and per row, look for disguised missing values (0, -1, 'N/A', empty strings, 1900-01-01 dates), and check whether a blank is missing by design (a field that does not apply).
- Ask why the data is missing: completely at random, at random given other columns, or not at random (the missingness depends on the value itself). That decides whether dropping rows biases the result.
- Choose per column: drop rows when few are affected and missingness is random; drop a column that is mostly empty and low value; impute median for skewed numbers, mode for categories, forward fill for time series, or a model-based method (KNN, iterative imputation); add an 'was missing' indicator when missingness itself carries signal.
- Know the tool behaviour: pandas isna().sum(), dropna() and fillna(); pandas mean() skips NaN by default; SQL AVG and COUNT(column) ignore NULLs while COUNT(*) does not; COALESCE supplies defaults.
- Avoid leakage and keep it auditable: fit imputation on training data only, compare distributions before and after, log every rule applied, and report systematic gaps to the source system owners so they are fixed upstream.
Follow-up
- When does filling with the mean do harm (it shrinks variance and weakens correlations)?
- A lab result is blank because the test was never ordered. How do you treat that column?
- How would you turn these checks into an automated step in a data pipeline?
Describe how you would approach optimizing a slow-running application.
Describe how you would approach optimizing a slow-running application.
Approach
- Define slow precisely: which operation, at which percentile (p50 versus p99), under what load, and what target counts as fixed; then reproduce it with representative data.
- Profile instead of guessing: APM or tracing to split request time between application code, database and external calls, a CPU profiler or flame graph for hot code, and EXPLAIN ANALYZE for slow queries.
- Fix the usual culprits in order of payoff: N+1 queries (replace with a join or batch fetch), missing indexes, fetching unused columns or unbounded result sets (add pagination), a quadratic algorithm replaceable by a hash map, undersized connection pools, and blocking I/O that can run concurrently or be cached.
- For front-end slowness: bundle size, uncompressed assets, missing CDN or cache headers, and too many round trips.
- Verify with a before-and-after benchmark under the same load, add a performance regression test, and recall Amdahl's law: the total speedup is limited by the share of time the optimised part took.
Follow-up
- The database query is fast when run alone but slow inside the app. What could explain that (lock contention, pool exhaustion, network, different query plan)?
- Memory grows until the service restarts. How do you find the leak?
- How would you catch a performance regression before it reaches production?
You need to implement a new feature with limited specifications. How would you proceed?
You need to implement a new feature with limited specifications. How would you proceed?
Approach
- Start from the problem, not the feature: identify the users and stakeholders, ask what decision or task the feature supports, and write down your assumptions so someone can confirm or correct them.
- Define the smallest useful slice with explicit acceptance criteria (given / when / then), and use a mockup or a prototype to get feedback before investing in the full build.
- Design so wrong guesses are cheap: hide the feature behind a flag, keep interfaces narrow, and delay hard-to-reverse choices such as data model migrations or public API shapes until the assumptions are confirmed.
- Keep the non-functional requirements even when the spec omits them: security and access control, input validation, accessibility, logging and tests.
- Ship to a small group, collect feedback and usage data, iterate, and record decisions and their reasons (an architecture decision record) so the next person knows why it works the way it does.
Follow-up
- The stakeholder is unavailable for weeks. What do you build in the meantime?
- Which assumption would you validate first, and how would you choose?
- Requirements changed after the feature shipped. How did your design absorb the change?
How would you evaluate the success of a software implementation?
How would you evaluate the success of a software implementation?
Approach
- Agree on success criteria before launch, tied to the reason the software was built: adoption (active users, task completion rate), reliability (uptime and latency against an SLO, incident count), quality (defect escape rate) and the business outcome (processing time, error rate, manual work removed).
- Capture a baseline before rollout and compare against it afterwards; use a phased rollout or A/B test where possible so the change can be attributed to the software rather than to seasonality or other releases.
- Add qualitative evidence: user interviews, usability testing, support ticket volume and themes.
- For the delivery side, the DORA metrics are standard: deployment frequency, lead time for changes, change failure rate, and time to restore service.
- Set guardrail metrics that must not get worse (error rate, accessibility issues, cost), report results honestly, and feed gaps into the next iteration.
Follow-up
- The headline metric improved but users are complaining. How do you reconcile that?
- How would you measure success for an internal tool with no revenue attached?
- How do you separate the effect of the new system from a seasonal change in workload?
How would you approach debugging a complex application?
How would you approach debugging a complex application?
Approach
- Reproduce first: capture the exact input, environment, version and user steps, then turn the failure into a deterministic failing test before touching code.
- Gather evidence before theorising: logs joined by a correlation or request id, metrics around the time the symptom started, distributed traces, and a list of what changed (deploys, config, dependency versions, data volume).
- Narrow the search space by halving it: git bisect across commits, disable components or feature flags, and isolate layers (client, API, service, database) so each experiment rules out half the candidates.
- Pick the tool for the symptom: a debugger with conditional breakpoints for logic errors, a thread dump (jstack or equivalent) for hangs and deadlocks, a heap dump for memory growth, a profiler for slowness.
- Fix the root cause rather than the trigger, keep the failing test as a regression test, verify in staging, and write a short post-incident note on detection and prevention.
Follow-up
- The bug only happens in production and never locally. What do you do next?
- How would you track down an intermittent failure you suspect is a race condition?
- How do you debug a problem when you cannot copy production data to your machine because it contains patient information?
The plan follows the reported loop: background and stack first, then coding, problem-solving cases, system design, fundamentals and cloud, behavioral stories, and a full rehearsal. Each day lists the reported questions it practises.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the loop and your background against the stack
- Write the three reported rounds (Phone Screen, Technical Assessment, In-Person Interviews) and beside each list the question types you will practise for it.
- List your experience against the languages (Java, C#, Python), frameworks (Spring, .NET) and clouds (AWS, Azure) candidates describe, marking each as strong, usable or gap.
- Write and read aloud a short career narrative that ends with why this role and healthcare software.
Deliverable: A one-page loop map, a stack gap list, and a written background narrative for the phone screen.
02Coding fundamentals in your strongest language
- Implement linked-list reversal iteratively and recursively, with tests for empty, single-node and long lists.
- Implement binary search, including a variant that returns the first matching position, and test missing, first and last targets.
- Solve a sorting problem, write a merge sort or quicksort, and say when you would rely on the built-in sort instead.
- For every solution, say its time and space complexity aloud and note the worst case.
Deliverable: Working, tested solutions for reversal, binary search and a sort, plus a spoken complexity statement for each.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗03Problem-solving cases: debug, optimise, clean, scope
- Write a debugging playbook for a complex application you know, from reproduction through narrowing to a regression test.
- Profile a slow function or query of your own and record the measurement, the change and the new measurement.
- Outline a missing-values cleaning routine: locate and quantify gaps, judge whether they are random, then drop, impute or flag with reasons.
- Write short answers to the late project, thin-specification feature and success-measurement questions, each naming a first action and a signal you would watch.
Deliverable: A written playbook for each of the six problem-solving questions, with the profiling before-and-after numbers.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗04System design with a healthcare lens
- Sketch the patient-records system: data model, API, access control, audit trail, encryption, storage and scaling, and explain the failure behaviour.
- Write a microservices-versus-monolith comparison and a recommendation for a stated team size and workload.
- Build a security checklist for a healthcare application and a plan for scaling an application under growing demand.
- Prepare an integration project story and work PracHub's practice question on holding a per-tenant active cap against concurrent creates to rehearse reasoning about concurrent writes.
Deliverable: A patient-records design diagram, a microservices-versus-monolith recommendation, a security checklist, a scaling outline and an integration story.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗05Fundamentals and cloud experience
- Write a concise answer for the software development lifecycle that mentions testing, review and maintenance, with an example from your own work.
- Explain the main principles of object-oriented programming with a short code example in your language, including where inheritance goes wrong.
- Prepare the cloud project story: workload, services, security, deployment and one failure, naming only platforms you have used.
Deliverable: A spoken lifecycle answer, an object-oriented answer with code, and a written outline of the cloud project story.
Practice prompt ↗Practice prompt ↗Practice prompt ↗06Behavioral story bank
- Write six to eight STAR stories covering a significant challenge, quick learning of a technology, prioritisation, teamwork, persuasion, conflict and a code optimisation.
- For each story, write the one decision you made, the alternative you rejected and the measurable result.
- Record yourself telling each story aloud and trim any that spend longer on setup than on your decision.
Deliverable: A story bank with each story mapped to the prompts it can answer, and a recording of each told aloud.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗07Full rehearsal in the reported order
- Deliver your background narrative as if on the phone screen.
- Solve a coding problem and one problem-solving case aloud, as in the technical assessment.
- Answer the patient-records design question and two behavioral stories as in the in-person stage, then list your three weakest answers.
Deliverable: Notes from the rehearsal and a short list of the three answers to rework before the loop.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Expand any day for tasks and deliverables. Your progress is saved on this device.
The In-Person Interviews are reported to include behavioral assessment and a fit conversation, and the reported prompts cover challenge, learning, prioritising, teamwork, persuasion and conflict. For a Software Engineer, prepare stories from real delivery work: a failing project, a new cloud or framework, a performance fix, and a disagreement over a technical choice. Use the STAR structure and make your own decision visible in each one.
Describe a time when you had to learn a new technology quickly.
Describe a time when you had to learn a new technology quickly.
Approach
- Choose a story where a deadline or production need forced the learning, such as a cloud service, a framework like Spring or .NET, or a new language. Say what was at stake in one or two sentences.
- Describe your learning method concretely: reading the official documentation first, building the smallest end-to-end slice, writing tests against it, and asking a person who already knew the technology to review it.
- Show how you decided what to learn first and what to skip until later; prioritising by what the task needed shows judgement better than listing everything you studied.
- Close with the result and one thing you got wrong early and corrected. A story with no mistakes sounds invented, and a story about only watching tutorials shows no delivery.
Follow-up
- What did you misunderstand at first, and how did you find out?
- How would you help a teammate pick up the same technology?
- How did you decide the code was good enough to ship without deep expertise?
What is your experience with cloud platforms, and how have you used them in past projects?
What is your experience with cloud platforms, and how have you used them in past projects?
Approach
- Lead with one specific workload rather than a list of services: what it did, how many components it had, and which platform it ran on (AWS or Azure are the ones the role lists). Say which parts you built or owned.
- Walk through the choices in order: compute, storage and database, networking, and identity. For each, give the reason you picked it and the alternative you rejected.
- Include security as part of the story: least-privilege roles, secrets kept out of code, encryption of data at rest and in transit. Security practice is a reported must-have for this role.
- Cover operations: how you deployed (pipeline, infrastructure as code), how you monitored it and how you rolled back. Finish with a trade-off or failure, such as cost, a permissions mistake or a scaling limit, and what you changed.
Follow-up
- Why that service rather than the alternative on the same platform?
- How did you handle deployment, configuration and rollback?
- What did it cost to run, and what would you do to reduce that?
Describe a time when you faced a significant challenge in a project. How did you handle it?
Describe a time when you faced a significant challenge in a project. How did you handle it?
Approach
- Choose a challenge with technical stakes where you made the key decision, such as a failing migration, a missed integration or an unstable release. State the situation in two sentences and the goal you were held to.
- Show the options you weighed and why you chose one: for example a rollback versus a forward fix, or cutting scope versus moving the date. The reasoning is the part that carries the answer.
- Describe your actions in first person, including how you communicated risk to teammates and product managers while the problem was live.
- End with a measurable outcome and a lesson you applied afterwards. A challenge that was only another person being difficult, or one you caused without owning it, weakens the story.
Follow-up
- What would you do differently if you faced it again?
- How did you know your fix worked rather than the problem having gone quiet?
- Who disagreed with your approach, and how did you handle that?
How do you prioritize your work when faced with multiple deadlines?
How do you prioritize your work when faced with multiple deadlines?
Approach
- Give a method before the story: sort work by impact and hard deadline, find dependencies that block others, estimate effort, then do the item that unblocks the most value first.
- Use a real case with three or more competing items, and say which one you deferred or cut and why. Naming what you did not do is what shows prioritisation.
- Show how you communicated: telling the affected product manager or teammate early about the trade-off and agreeing the new order, rather than silently missing a date.
- Mention how you track the work, such as a visible board or a written list, and how you re-plan when something urgent arrives. Close with the result.
Follow-up
- What do you do when two stakeholders each say their item is the top priority?
- Describe a time you still missed a deadline and what you did next.
- How do you protect time for testing and documentation when schedules are tight?
Give an example of how you have worked effectively in a team setting.
Give an example of how you have worked effectively in a team setting.
Approach
- Pick a team story with a clear shared goal, give the team size and your role, and then focus on your own contribution rather than the team's overall success.
- Choose contributions that go beyond writing code, such as code reviews with specific feedback, writing documentation others used, pairing with a newer teammate, or aligning with product managers and data analysts on requirements.
- Describe one moment of friction or a gap, such as a blocked teammate or unclear ownership, and what you did about it.
- State the outcome in concrete terms and what the team did differently afterwards. Saying only that the team got on well, with no action of yours, gives the listener nothing to assess.
Follow-up
- Tell me about a time your team disagreed on a technical approach.
- How do you give feedback in a code review when you think the design is wrong?
- What did you do when a teammate was struggling or blocked?
Discuss a time when you had to convince others to adopt your viewpoint.
Discuss a time when you had to convince others to adopt your viewpoint.
Approach
- Choose a technical or process viewpoint you held, such as a design choice, a testing approach or a tool, where the others initially disagreed. Say what the decision affected.
- Show that you understood the other positions first: summarise their concerns fairly before arguing your own. This separates persuasion from stubbornness.
- Describe the evidence you used, such as a small prototype, a benchmark, a risk list or an example from a past incident, and how you adapted the explanation to the audience.
- Give the real outcome, including partial wins or the time you were overruled and committed anyway. A story in which you were simply right and everyone agreed is the weak version.
Follow-up
- What if the evidence had pointed the other way?
- How did you treat the people who still disagreed afterwards?
- How would you make the same case to a non-technical stakeholder?
How do you handle conflicts with team members?
How do you handle conflicts with team members?
Approach
- Choose a real disagreement about work, such as a design, a review comment or ownership of a task, rather than a personality clash. Keep the other person's description respectful.
- Start with what you did first: you spoke directly and privately, listened to their reasoning and restated it, and looked for the shared goal such as the release or the users.
- Move the discussion to facts: a test, a measurement, a written comparison, or a decision-maker's call if the two of you could not settle it. Say how you decided.
- End with the resolution and the working relationship afterwards. Avoid claiming you never have conflicts, and avoid casting the other person as the villain.
Follow-up
- What would you do if the person would not engage?
- When do you escalate to a manager, and what do you bring when you do?
- What did the episode change about how you work with others?
Provide an example of a time when you optimized a piece of code or algorithm.
Provide an example of a time when you optimized a piece of code or algorithm.
Approach
- Open with the baseline: what was slow or heavy, how you measured it (a profiler, timing, query plans, logs) and the number you started from. Optimising without a measurement is the common weak point.
- Name the bottleneck you found and the change: a better algorithm or data structure, removing repeated work, batching, indexing or caching. Give the complexity or cost before and after.
- Say how you protected correctness: existing tests, new tests for edge cases and a comparison of output before and after the change.
- Re-measure and report the result, then state the trade-off you accepted, such as readability, memory or cache invalidation, and why it was acceptable.
Follow-up
- How did you establish that this was the real bottleneck?
- What was the time or space complexity before and after?
- Did the change make the code harder to maintain, and how did you manage that?
- 01
Describe a time when you faced a significant challenge in a project. How did you handle it?
- 02
Describe a time when you had to learn a new technology quickly.
- 03
How do you prioritize your work when faced with multiple deadlines?
- 04
Discuss a time when you had to convince others to adopt your viewpoint.
- 05
How do you handle conflicts with team members?
- 06
What is your experience with cloud platforms, and how have you used them in past projects?
How many rounds are there and how long does the process take?
Candidates report three rounds: a Phone Screen, a Technical Assessment and In-Person Interviews, over roughly three to five weeks. Candidates also say that individual teams can vary the process, so confirm the format with your recruiter.
Centers for Medicare & Medicaid Services Software Engineer candidate reports ↗Which languages and tools should I prepare?
The role as candidates describe it lists Java, C# or Python, frameworks such as Spring or .NET, and cloud experience on AWS or Azure. Pick the language you code fastest in for the technical assessment, and be ready to discuss one real cloud project in detail.
Centers for Medicare & Medicaid Services Software Engineer candidate reports ↗What kinds of questions are reported?
Five groups: technical fundamentals (lifecycle, object-oriented principles, debugging, cloud experience), system design (patient records, microservices against a monolith, healthcare security, scaling, integration), behavioral prompts, problem-solving cases (late project, missing values, slow application, thin specification, measuring success) and coding (linked list reversal, binary search, sorting, complexity).
Centers for Medicare & Medicaid Services Software Engineer candidate reports ↗Do I need healthcare domain knowledge?
Knowledge of healthcare systems is listed as a nice-to-have rather than a requirement, alongside agile experience and familiarity with data analytics tools. The listed must-haves are cloud platform experience, security practice and software design principles, so spend most of your time there. Read about the programs the agency runs so you can say why the work interests you.
Centers for Medicare & Medicaid Services Software Engineer candidate reports ↗How should I prepare for the behavioral questions?
Candidates are advised to structure answers with Situation, Task, Action and Result. Build six to eight real stories, each with one decision of your own and a measurable result, and map each to several prompts, such as a challenge, a deadline, a conflict and a persuasion.
Centers for Medicare & Medicaid Services Software Engineer candidate reports ↗How much experience do candidates typically have?
The requirements candidates describe mention typically three to five years of relevant experience in software engineering or a related field. If you have less, lean on projects where you owned a component end to end, including its tests, documentation and deployment.
PracHub Software Engineer practice ↗Sources & methodology 3 sources ↗
No official company page is cited. Rounds and questions come from candidate reports and PracHub editorial material; each source shows the date it was read.
- 01Centers for Medicare & Medicaid Services Software Engineer candidate reports ↗
Company-reported rounds, questions and FAQ.
Candidate reports · Accessed 2026-09-22 - 02PracHub Software Engineer practice ↗
PracHub practice material, not company-reported.
PracHub page · Accessed 2026-09-22 - 03PracHub preparation framework ↗
PracHub preparation guidance.
PracHub page · Accessed 2026-09-22
Explore related engineering environments and compare the preparation focus.
Vercel Software Engineer Interview Guide
Debugging practice for Vercel software engineer prep built on a reproduction you trust, narrowing to the smallest failing input, and changing one variable per run so the result stays attributable.
CoreWeave Software Engineer Interview Guide
Failure-handling practice for CoreWeave software engineer candidates: requests whose outcome a timeout leaves unknown, where a retry is safe, and deduplicating at the receiver instead of assuming exactly-once delivery.
Confluent Software Engineer Interview Guide
Concurrency exercises for Confluent candidates: check-then-act races, deadlock from inconsistent lock ordering, and why two individually atomic operations do not compose into an atomic update.
Capital One Software Engineer Interview Guide
Code-reading and review practice for Capital One candidates: tracing unfamiliar control flow, finding the invariant a function quietly depends on, and separating a correctness defect from a matter of taste.