As a Software Engineer at Imubit, you will work at the cutting edge of industrial artificial intelligence, building systems that directly optimize massive physical infrastructure. Imubit specializes in closed-loop Deep Reinforcement Learning (RL) solutions for the refining, petrochemical, and process industries. In this role, you are not building standard SaaS applications; instead, you are engineering highly reliable, real-time optimization pipelines that interface with complex, multi-million-dollar physical assets. The software you write plays a critical role in translating complex physical constraints—such as temperature, pressure, and flow rates—into mathematical formulations that reinforcement learning models can optimize. This requires an exceptionally high standard of software engineering. The systems must operate with 24/7 reliability, as any latency or software failure could have significant real-world physical and financial consequences. You will collaborate closely with a multidisciplinary team of deep learning scientists, product managers, and chemical process engineers. Your primary impact lies in scaling these optimization models, ensuring seamless data ingestion from industrial plants, and building robust APIs and platforms that make these advanced AI capabilities accessible and actionable for plant operators.
HR Screening
reportedInitial discussion about your background, experience, and alignment with the company's domain.
What to demonstrate
- Initial discussion about your background, experience, and alignment with the company's domain
- Depth in Deep Learning (DL)
How to prepare
- Be able to walk your CV end to end in two minutes, and say why this company specifically.
- Have your salary expectations, notice period and location constraints ready, and ask for the rest of the loop in writing.
Technical Discussion
reportedLive coding session focusing on core algorithms and system design.
What to demonstrate
- Live coding session focusing on core algorithms and system design
- Depth in Deep Learning (DL)
How to prepare
- Answer aloud and timed: Solve a classic array or string manipulation problem, optimizing for both time and space complexity.
- Answer aloud and timed: How would you handle and validate edge cases in a data ingestion pipeline to prevent corrupt data from reaching a downstream model?
Home Assignment
reportedComprehensive assignment combining software engineering with practical machine learning or deep learning tasks.
What to demonstrate
- Comprehensive assignment combining software engineering with practical machine learning or deep learning tasks
- Depth in Deep Learning (DL)
How to prepare
- Answer aloud and timed: Walk through a previous project where you deployed a machine learning model. What challenges did you face, and how did you resolve them?
- Answer aloud and timed: Explain the difference between overfitting and underfitting. What techniques would you use to mitigate overfitting in a deep neural network?
Schematic Review
reportedDetailed review round focusing on the technical aspects of the home assignment.
What to demonstrate
- Detailed review round focusing on the technical aspects of the home assignment
- Depth in Deep Learning (DL)
How to prepare
- Answer aloud and timed: How do you evaluate the performance of a model when the training data is highly imbalanced or noisy?
- Answer aloud and timed: What are the core components of a reinforcement learning system, and how do they map to a physical control environment?
Final Conversations
reportedConversations with engineering leadership to discuss fit and expectations.
What to demonstrate
- Conversations with engineering leadership to discuss fit and expectations
- Depth in Deep Learning (DL)
How to prepare
- Answer aloud and timed: Reviewing this process flow diagram, how does an increase in the reflux rate impact the overall tower temperature?
- Answer aloud and timed: If the reactor temperature increases, what is the expected impact on product yields and downstream separation columns?
PracHub editorial advice for the preparation topics above.
Budget Time for the Home Assignment
The take-home assignment is comprehensive and highly detailed.
The home assignment is estimated by the company to take between 1 to 3 days of dedicated effort
Ensure you plan your schedule carefully and request the prompt only when you have sufficient block of time to dedicate to it.
Brush Up on Basic Process Control Concepts
You do not need to be an expert, but having a basic understanding of variables like flow, temperature, and pressure will help you immensely.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
Implement a function to detect cycles in a directed graph representing a process flow.
Implement a function to detect cycles in a directed graph representing a process flow.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Given a stream of real-time sensor data, write an efficient algorithm to calculate the moving average within a
Given a stream of real-time sensor data, write an efficient algorithm to calculate the moving average within a sliding time window.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Solve a classic array or string manipulation problem, optimizing for both time and space complexity.
Solve a classic array or string manipulation problem, optimizing for both time and space complexity.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
How would you handle and validate edge cases in a data ingestion pipeline to prevent corrupt data from reachin
How would you handle and validate edge cases in a data ingestion pipeline to prevent corrupt data from reaching a downstream model?
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Denormalise tenant onto revisions and backfill it live
resource_revision (revision_id, resource_id, version, actor_user_id, change_kind, patch, request_id, created_at) has 400M rows and no tenant column; tenant_id lives only on resource. Two reads need it: a tenant-scoped audit feed ordered by created_at DESC, and an offboarding purge. Both join back to resource today. Justify adding tenant_id to resource_revision against those two reads, name the anomaly the copy introduces and the constraint that prevents it, then give the ordered migration for a live table taking 1.2k writes/second — the lock each step takes, how the backfill is batched, and where each step stops being reversible. PostgreSQL 16.
Approach
- Justify from the access path rather than from taste. Without the column, the audit feed either scans resource_revision by created_at and discards other tenants' rows, or resolves the tenant's resource_ids first and probes with them — both proportional to the tenant's whole history rather than to one page. With (tenant_id, created_at DESC, revision_id DESC) it is a seek that stops at 50 rows, and the purge becomes a ranged delete instead of a join.
- Name the cost exactly: a second copy of a fact can disagree with the first. Make the disagreement unwritable rather than documented — add UNIQUE (resource_id, tenant_id) on resource so it can serve as a foreign-key target, then FOREIGN KEY (resource_id, tenant_id) REFERENCES resource (resource_id, tenant_id) on the revision table. A revision can then only ever carry its parent's tenant.
- Step one, expand: ALTER TABLE resource_revision ADD COLUMN tenant_id BIGINT NULL, with no default, so it is a catalogue change and no rewrite. It still needs ACCESS EXCLUSIVE for an instant, and that instant queues behind the longest open transaction on the table while every later query queues behind it — set lock_timeout to 2s and retry rather than wait.
- Step two, dual-write: deploy the writer that populates tenant_id on every new revision while reads still use the join. Reversible by redeploying the previous build, because nothing reads the column yet.
Follow-up
- The backfill is half finished and a rollback is required. What state is the table in, and what does the previous build do with a half-populated column?
- How do you verify the backfill actually finished, given rows are still being inserted while it runs?
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?
Walk through a previous project where you deployed a machine learning model. What challenges did you face, and
Walk through a previous project where you deployed a machine learning model. What challenges did you face, and how did you resolve them?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
Explain the difference between overfitting and underfitting. What techniques would you use to mitigate overfit
Explain the difference between overfitting and underfitting. What techniques would you use to mitigate overfitting in a deep neural network?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
How do you evaluate the performance of a model when the training data is highly imbalanced or noisy?
How do you evaluate the performance of a model when the training data is highly imbalanced or noisy?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
What are the core components of a reinforcement learning system, and how do they map to a physical control env
What are the core components of a reinforcement learning system, and how do they map to a physical control environment?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
Reviewing this process flow diagram, how does an increase in the reflux rate impact the overall tower temperat
Reviewing this process flow diagram, how does an increase in the reflux rate impact the overall tower temperature?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
If the reactor temperature increases, what is the expected impact on product yields and downstream separation
If the reactor temperature increases, what is the expected impact on product yields and downstream separation columns?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
How would you design a software interface to represent the hierarchical relationships between different physic
How would you design a software interface to represent the hierarchical relationships between different physical units in a refinery?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- State the consistency you need, and where you are willing to be stale.
Follow-up
- What breaks first when traffic grows ten times?
- How does this behave when that dependency is down for an hour?
Explain how you would model a closed-loop feedback controller in code.
Explain how you would model a closed-loop feedback controller in code.
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
Read latency spikes on a sixty-second sawtooth
The cached listing read path serves about 14k reads/second at an 85% hit rate. p99 sits at 35 ms for 57 seconds, jumps to 900 ms for 3, and repeats. During each spike the primary shows several hundred identical listing queries starting within the same millisecond, all carrying one large tenant's id. Cache entries use a 60-second TTL. Give the mechanism, the ordered checks, the fix, and the correctness hazard your fix must not introduce.
Approach
- Match the period to a configured number before theorising about load. A spike every 60 seconds against a 60-second TTL is an entry expiring, and you confirm it by correlating spike timestamps with the entry's write time rather than with the traffic curve. If the period had matched a cron or a GC interval instead, this is a different investigation.
- Establish the concurrency of the miss. Several hundred identical queries in one millisecond means the miss path has no coalescing: every request that arrives between expiry and repopulation recomputes. The herd size is that key's arrival rate times its recompute time, so at 1.2k reads/second for the hot key and a 250 ms recompute you expect about 300 concurrent misses, which matches what is observed.
- Add single-flight on the miss path so one caller per key recomputes under a short-lived lock while the rest wait for its result. Prefer stale-while-revalidate where the read tolerates it: return the expired value immediately and refresh asynchronously, which removes the latency spike rather than serialising it into a queue of waiters.
- De-synchronise the keys. Write TTLs with jitter, for example 60 seconds plus or minus 10%, so a deploy or a mass invalidation does not align every key on the same second and turn a per-key herd into a fleet-wide one.
Follow-up
- The same sawtooth appears on a key that is invalidated on write rather than expired. Is that the same bug?
- How does your answer change if the recompute takes 4 seconds instead of 250 ms?
Built from the rounds and topics Imubit candidates report.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the Imubit loop
- Write out the reported sequence: HR Screening, Technical Discussion, Home Assignment, Schematic Review, Final Conversations.
- For each round, write one sentence on what it is judging, from the description above, and mark the one you are least ready for.
Deliverable: A one-page map of the 5 reported rounds, with the weakest marked.
02Work Deep Learning (DL)
- Spend the session on Deep Learning (DL), which Imubit candidates report being tested on.
- Write one worked example in Deep Learning (DL) and time yourself on it.
Deliverable: One timed worked example in Deep Learning (DL).
03Work Coding (Algorithmic Implementation)
- Spend the session on Coding (Algorithmic Implementation), which Imubit candidates report being tested on.
- Write one worked example in Coding (Algorithmic Implementation) and time yourself on it.
Deliverable: One timed worked example in Coding (Algorithmic Implementation).
04Work Home Assignments (Take-home Coding)
- Spend the session on Home Assignments (Take-home Coding), which Imubit candidates report being tested on.
- Write one worked example in Home Assignments (Take-home Coding) and time yourself on it.
Deliverable: One timed worked example in Home Assignments (Take-home Coding).
05Answer out loud: Algorithmic Problem-Solving & Coding
- Answer aloud, timed: Implement a function to detect cycles in a directed graph representing a process flow.
- Answer aloud, timed: Given a stream of real-time sensor data, write an efficient algorithm to calculate the moving average within a sliding time window.
Deliverable: Spoken answers to 2 reported Algorithmic Problem-Solving & Coding question(s), under time.
06Answer out loud: Deep Learning & Machine Learning Concepts
- Answer aloud, timed: Walk through a previous project where you deployed a machine learning model. What challenges did you face, and how did you resolve them?
- Answer aloud, timed: Explain the difference between overfitting and underfitting. What techniques would you use to mitigate overfitting in a deep neural network?
Deliverable: Spoken answers to 2 reported Deep Learning & Machine Learning Concepts question(s), under time.
07Answer out loud: Industrial Process & Schematic Analysis
- Answer aloud, timed: Reviewing this process flow diagram, how does an increase in the reflux rate impact the overall tower temperature?
- Answer aloud, timed: If the reactor temperature increases, what is the expected impact on product yields and downstream separation columns?
Deliverable: Spoken answers to 2 reported Industrial Process & Schematic Analysis question(s), under time.
Expand any day for tasks and deliverables. Your progress is saved on this device.
Behavioural rounds judge the decision you made and what it cost.
Unblock an engineer without taking the keyboard
A teammate has spent two days on a job handler that occasionally writes duplicate rows. They are certain the queue is delivering twice by mistake. You suspect a lease expiring under a slow handler, so the job is running concurrently with itself. Describe how you have unblocked someone in this position: what you asked before offering a hypothesis, what you showed them rather than told them, and what you left them owning. Then say what you would do if their theory turned out to be the right one.
Approach
- Ask before diagnosing, and ask for things answerable from data they already have: the attempt count on the job rows that produced duplicates, the handler's observed duration against its lease expiry, and whether the duplicate rows share a natural key that a unique constraint could have caught.
- Teach the shape rather than the answer. A lease cannot distinguish a dead worker from a slow one, so a handler that outruns its lease is running twice by design, and deploys deliver the other half by killing handlers mid-run on every rollout. Both of their candidate theories produce identical duplicate rows, which is why the evidence has to come from timings rather than from argument.
- Hand over a checklist they execute: a natural key on every write the handler performs so the second copy collides rather than appends, the record of intent written before any external effect, a lease heartbeat while running, and the metric that shows it working.
- Keep ownership with them deliberately. Pair on the first write, then step back; if you finish it yourself you have closed one ticket and left the same person stuck on the next redelivery.
Follow-up
- How would you distinguish a genuine double-delivery from a lease expiry using only the data already stored?
- Their handler calls an external endpoint before recording that it did. What do you tell them to change first?
Ship under a deadline and bound the debt you chose
You have four days to ship a tenant-facing listing endpoint. The version you would defend uses keyset pagination over (tenant_id, status, updated_at DESC, resource_id DESC); the version you can finish uses LIMIT/OFFSET with no matching index. Describe a deadline call you actually made of this shape: what you shipped, what you knowingly deferred, how you bounded the damage with a mechanism rather than an intention, and the specific numeric condition that would force the follow-up. Name who you told and where you wrote it down.
Approach
- Name the deferred failure precisely instead of calling it slow. OFFSET n makes the database produce and discard n rows, so cost grows with page depth; without an index matching the sort, every matching row is read and sorted before the limit applies; and rows inserted between two page fetches shift across the boundary so items are skipped or repeated with nothing in the response to signal it.
- Bound the blast radius with something mechanical rather than a promise: cap maximum page depth, cap page size, restrict the endpoint to one internal caller, or keep it behind a flag. State which failure each cap removes and which it leaves standing.
- Attach a number to the trigger and wire it to an alarm: the first tenant crossing N resources, or the endpoint's p99 crossing its share of the 400 ms budget, so the debt announces itself instead of waiting to be remembered.
- Write it where the next engineer looks, which is the code and the ticket, not a chat message: what was deferred, why, the cap, and the trigger.
Follow-up
- At what page depth does the offset version breach your latency budget, given your page size and row counts?
- What breaks first when you switch to keyset pagination later, and what does a client holding an old page token see?
Argue against a design, lose, and commit anyway
Describe a design you argued against and lost. State the failure you predicted as a named mechanism, not a feeling about complexity: two services that would need one transaction, a projection with no rebuild path, a write path with no idempotency key. Say what evidence you brought, what the decision maker weighed instead, and what you did after the decision was made: what you instrumented, what you wrote down, and whether the prediction came true. Five minutes.
Approach
- State the prediction in falsifiable form up front: the mechanism, the condition that triggers it, and the observable outcome. A prediction that cannot be checked also cannot be credited to you later.
- Show the evidence you had at the time and label each piece honestly as measured, analogous, or intuition. Keeping the intuition is fine; disguising it as data is the thing that erodes your standing in the next argument.
- Represent the opposing case at full strength, including the constraint you did not control: a fixed date, a team boundary, or the fact that the decision was cheap to reverse and yours was not.
- Make disagree-and-commit concrete. Name the artefact you left behind so the prediction could be settled without you: the alert and its threshold, the counter on the dashboard, the decision note that recorded the trade-off and the condition that would revisit it.
Follow-up
- What threshold on that alert would have proved you right, and did anyone ever look at it?
- If the same proposal arrived tomorrow with the same deadline, would you argue it the same way?
- 01
A teammate has spent two days on a job handler that occasionally writes duplicate rows. They are certain the queue is delivering twice by mistake. You suspect a lease expiring under a slow handler, so the job is running concurrently with itself. Describe how you have unblocked someone in this position: what you asked before offering a hypothesis, what you showed them rather than told them, and what you left them owning. Then say what you would do if their theory turned out to be the right one.
- 02
You have four days to ship a tenant-facing listing endpoint. The version you would defend uses keyset pagination over (tenant_id, status, updated_at DESC, resource_id DESC); the version you can finish uses LIMIT/OFFSET with no matching index. Describe a deadline call you actually made of this shape: what you shipped, what you knowingly deferred, how you bounded the damage with a mechanism rather than an intention, and the specific numeric condition that would force the follow-up. Name who you told and where you wrote it down.
- 03
Describe a design you argued against and lost. State the failure you predicted as a named mechanism, not a feeling about complexity: two services that would need one transaction, a projection with no rebuild path, a write path with no idempotency key. Say what evidence you brought, what the decision maker weighed instead, and what you did after the decision was made: what you instrumented, what you wrote down, and whether the prediction came true. Five minutes.
How difficult is the interview process at Imubit?
The process is generally rated as moderate to difficult. It is highly practical and requires a significant time commitment, particularly for the take-home assignment, which simulates real-world engineering challenges you would face on the job.
Imubit Software Engineer candidate reports ↗Do I need a background in chemical engineering to apply?
No, a background in chemical engineering is not required. However, you must possess strong analytical reasoning skills and a high degree of curiosity to learn about physical systems, as you will be expected to analyze process flow diagrams during the interview.
Imubit Software Engineer candidate reports ↗What is the purpose of the schematic review round?
This round evaluates your ability to think logically about complex, interconnected systems. The interviewers want to see how you analyze physical variables and relationships, which is a core part of translating industrial processes into software configurations.
Imubit Software Engineer candidate reports ↗How long does the hiring process typically take?
The process can move quickly in terms of scheduling, but the overall duration is heavily influenced by the time you take to complete the home assignment. On average, the process takes between three to six weeks from the initial screen to the final decision.
Imubit Software Engineer candidate reports ↗What topics does Imubit test in interviews?
Imubit interviews most often cover Problem Solving, Deep Learning (DL), Home Assignment / Take-home Challenges, Coding (Algorithmic Implementation), and Assignment Review / Code Walkthrough. The exact emphasis depends on the specific role you apply for.
Imubit Software Engineer candidate reports ↗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.
- 01Imubit 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.
Overjet Software Engineer Interview Guide
What Overjet asks Software Engineer candidates, from reported rounds and questions.
Mirage Software Engineer Interview Guide
What Mirage asks Software Engineer candidates, from reported rounds and questions.
Johns Hopkins Applied Physics Laboratory Software Engineer Interview Guide
What Johns Hopkins Applied Physics Laboratory asks Software Engineer candidates, from reported rounds and questions.
Discord Software Engineer Interview Guide
Database practice for Discord candidates: how an index changes a query plan, and which anomalies survive a given isolation level, since read committed still permits non-repeatable reads.