cswork / libraryOpen practice workspace

Interview guides · IERUS Technologies

IERUS Technologies Software Engineer Interview Guide

IERUS Technologies Software Engineer interview guide: reported rounds, questions and how candidates describe the process.

The 60-second brief

As a Software Engineer at IERUS Technologies, you are joining a company deeply rooted in engineering excellence, where the primary mission is to accelerate the technology life cycle for defense and commercial customers. IERUS Technologies specializes in electromagnetics, computational analytics, and weapon systems engineering, meaning your work directly influences high-stakes projects like the Missile Defense System (MDS). This role is not merely about writing code; it is about solving complex physics-based problems using advanced algorithms, machine learning, and high-performance computing. You will contribute to the entire development lifecycle, from early discovery and simulation infrastructure design to integration and high-rate production.

This guide is scoped to a Software Engineer candidate at IERUS Technologies.

Focus areas

  • C++
  • Modeling & Simulation (M&S)
  • Multi-threaded programming

The IERUS Technologies interview process

IERUS Technologies candidates report 4 rounds over 3-5 weeks. The stages below are what candidates describe, not a published process.

Initial Screening

Conducted by technical leads or scientists to assess basic qualifications.

What to demonstrate

  • Conducted by technical leads or scientists to assess basic qualifications
  • Depth in C++

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.

In-Depth Technical Rounds

Multiple rounds focusing on specific technical challenges and expertise.

What to demonstrate

  • Multiple rounds focusing on specific technical challenges and expertise
  • Depth in C++

How to prepare

  • Answer aloud and timed: What is your experience with GPU programming or high-performance computing (HPC) environments?
  • Answer aloud and timed: How do you handle integration between C++ and scripting languages like Python or MATLAB?

Technical Topic Presentation

Candidates may present a technical topic of their choice to demonstrate preparation and communication skills.

What to demonstrate

  • Candidates may present a technical topic of their choice to demonstrate preparation and communication skills
  • Depth in C++

How to prepare

  • Answer aloud and timed: Discuss your familiarity with Object-Oriented Design (OOD) patterns and how they apply to large-scale simulation tools.
  • Answer aloud and timed: How many ML/AI projects have you completed, and what were the specific outcomes?

High-Level Discussions

Engagements about career trajectory and fit for specific programs.

What to demonstrate

  • Engagements about career trajectory and fit for specific programs
  • Depth in C++

How to prepare

  • Answer aloud and timed: Can you explain how you would select between supervised methods like SVM or Tree Ensemble models for a specific sensor-fusion task?
  • Answer aloud and timed: How do you handle missing data or noise in a real-time signal processing environment?

Where candidates lose points

Prepare your portfolio

If asked to present, choose a topic that demonstrates your ability to solve a complex, physics-based problem.

Be ready for small talk

You may meet with multiple teams; keep your energy high and be prepared to introduce your background multiple times.

Understand the domain

Familiarize yourself with the basics of the Ballistic Missile Defense System (BMDS) or the specific domain (Radar/RF) related to the job title.

Show your work

When answering technical questions, always explain your assumptions and the logic behind your chosen solution.

Questions & practice

Explain your experience with C++ and how you manage memory or multi-threading in high-performance applications

Medium · Technical and Domain Expertise

Explain your experience with C++ and how you manage memory or multi-threading in high-performance applications.

Approach

  1. Say what the runtime actually does before reasoning about the code.
  2. Name what is shared across threads and what owns each piece of state.
  3. Identify the window where an invariant is briefly untrue.
  4. Distinguish a value from a reference to it, and say which one you handed out.

Follow-up

  • What happens if two callers reach this at the same time?
  • Where could this allocate more than you expect?

How many ML/AI projects have you completed, and what were the specific outcomes?

Medium · Machine Learning and Algorithms

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. 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?

Can you explain how you would select between supervised methods like SVM or Tree Ensemble models for a specifi

Medium · Machine Learning and Algorithms

Can you explain how you would select between supervised methods like SVM or Tree Ensemble models for a specific sensor-fusion task?

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. 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?

Describe your process for optimizing an algorithm for speed and accuracy.

Medium · Machine Learning and Algorithms

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. 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?

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

  1. 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.
  2. 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.
  3. 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.
  4. 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?

Hold a per-tenant active cap against concurrent creates

Hard · write skew · isolation levels · constraints

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

  1. 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.
  2. 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.
  3. 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.
  4. 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?

How would you approach designing a simulation framework for a complex system?

Medium · Technical and Domain Expertise

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

Discuss your familiarity with Object-Oriented Design (OOD) patterns and how they apply to large-scale simulati

Medium · Technical and Domain Expertise

Discuss your familiarity with Object-Oriented Design (OOD) patterns and how they apply to large-scale simulation tools.

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

Edge instances grow 400 MB per hour until the nightly restart

Hard · memory leak · heap analysis · metric cardinality

Edge API instances start at 700 MB resident and grow about 400 MB/hour; a nightly rolling restart has hidden it for weeks. Growth continues unchanged when request rate halves overnight, p99 degrades in the last hours before an instance is recycled, and heap used immediately after a forced full GC rises monotonically. The service holds no product state. Name the discriminating measurement that separates the plausible causes, give the most likely cause, and give the fix and how you would verify it.

Approach

  1. Separate resident memory from live heap first, because they fail differently. Resident size can grow from fragmentation, native buffers or thread stacks while the heap is flat; heap used after a full GC rising monotonically is the measurement that says objects are reachable and not being released. You already have it, so this is retention, not fragmentation, and that closes off half the candidate list.
  2. Use the rate's independence from traffic as the discriminator. Growth that continues at half the request rate rules out per-request objects that are merely slow to collect and points at a structure that grows with distinct values observed rather than with call volume. Write the candidates that have that property: a metrics registry keyed on a high-cardinality label, an unevicted cache, an interner, a per-key lock map.
  3. Take two heap snapshots an hour apart and diff by retained size, reading the dominator tree, not by allocation count or instance count. Expect one root holding a map with millions of entries, then follow the reference chain to the code that inserts and never removes. Allocation profilers point at churn, which is the wrong signal here.
  4. The candidate that fits this service is an observability label carrying an identifier, such as a request path recorded before templating so that /v1/resources/48213 becomes its own metric series. That grows with distinct ids seen, is independent of rate, and explains the late p99 degradation, since GC cost rises with the size of the live set.

Follow-up

  • Post-GC heap is now flat but resident size still creeps. What are you looking at, and does it matter?
  • How would you have detected this before an OOM, given the nightly restart masked the trend?

Suggested practice checklist

Built from the rounds and topics IERUS Technologies candidates report.

Day 1 — Map the IERUS Technologies loop

  • Write out the reported sequence: Initial Screening, In-Depth Technical Rounds, Technical Topic Presentation, High-Level Discussions.
  • 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 4 reported rounds, with the weakest marked.

Day 2 — Work C++

  • Spend the session on C++, which IERUS Technologies candidates report being tested on.
  • Write one worked example in C++ and time yourself on it.

Deliverable: One timed worked example in C++.

Day 3 — Work Modeling & Simulation (M&S)

  • Spend the session on Modeling & Simulation (M&S), which IERUS Technologies candidates report being tested on.
  • Write one worked example in Modeling & Simulation (M&S) and time yourself on it.

Deliverable: One timed worked example in Modeling & Simulation (M&S).

Day 4 — Work Multi-threaded programming

  • Spend the session on Multi-threaded programming, which IERUS Technologies candidates report being tested on.
  • Write one worked example in Multi-threaded programming and time yourself on it.

Deliverable: One timed worked example in Multi-threaded programming.

Day 5 — Answer out loud: Technical and Domain Expertise

  • Answer aloud, timed: How would you approach designing a simulation framework for a complex system?
  • Answer aloud, timed: Explain your experience with C++ and how you manage memory or multi-threading in high-performance applications.

Deliverable: Spoken answers to 2 reported Technical and Domain Expertise question(s), under time.

Day 6 — Answer out loud: Machine Learning and Algorithms

  • Answer aloud, timed: How many ML/AI projects have you completed, and what were the specific outcomes?
  • Answer aloud, timed: Can you explain how you would select between supervised methods like SVM or Tree Ensemble models for a specific sensor-fusion task?

Deliverable: Spoken answers to 2 reported Machine Learning and Algorithms question(s), under time.

Day 7 — Answer out loud: Behavioral and Professional Growth

  • Answer aloud, timed: Why did you receive poor marks in a particular academic course, and would you want to retake it?
  • Answer aloud, timed: Describe a situation where you had to explain a complex technical concept to a stakeholder or non-technical team member.

Deliverable: Spoken answers to 2 reported Behavioral and Professional Growth question(s), under time.

Behavioural preparation

Behavioural rounds judge the decision you made and what it cost.

What is your experience with GPU programming or high-performance computing (HPC) environments?

Medium · Technical and Domain Expertise

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

How do you handle integration between C++ and scripting languages like Python or MATLAB?

Medium · Technical and Domain Expertise

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

How do you handle missing data or noise in a real-time signal processing environment?

Medium · Machine Learning and Algorithms

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

Why did you receive poor marks in a particular academic course, and would you want to retake it?

Medium · Behavioral and Professional Growth

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

Describe a situation where you had to explain a complex technical concept to a stakeholder or non-technical te

Medium · Behavioral and Professional Growth

Describe a situation where you had to explain a complex technical concept to a stakeholder or non-technical team member.

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

How do you handle working on multiple, rapidly changing contract requirements?

Medium · Behavioral and Professional Growth

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

What are you doing to stay current with emerging technologies in the defense or software industry?

Medium · Behavioral and Professional Growth

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?