Interview guides · Aquila Technology

Aquila Technology Software Engineer Interview Guide

Aquila Technology Software Engineer interview guide: the 5 reported rounds, coding, system design and behavioral questions, and a 7-day prep plan.

The 60-second brief

Candidates describe Aquila Technology as a company that builds software for national security and defense work. Software Engineer roles sit on teams such as Cyber Network Operations (CNO) and teams that build analytic tools for intelligence, surveillance and reconnaissance missions. The day-to-day work in the role descriptions covers the full cycle: designing, writing, testing and deploying applications, gathering requirements with other teams, taking part in code review and tracking down defects. The languages listed are Python, Java or C++, with Git and JIRA as everyday tools and Agile or Scrum as the working method.

This guide is for engineers applying to a Software Engineer role at Aquila Technology, including anyone aiming at the CNO or analytic-tools teams. It walks through the five stages candidates report and gives question-specific approaches for all 15 reported questions. These cover coding fundamentals (reversing a string, binary search, dynamic programming), design (a real-time web application, database schema choices, performance against scalability), domain knowledge (your languages, object-oriented programming), problem-solving cases (feature prioritisation, a slow application, testing before deployment) and behavioral stories. It does not cover Data Scientist or ML Engineer loops.

Candidates report five stages over about 4-6 weeks: Resume Submission, Email Communication, Online Assessment, Technical Interview and Final Interviews. In some loops a technical interview is scheduled where others get an assessment link.

Focus areas

Software Engineering
Software Engineer Responsibilities
CNO Reverse Engineering

Overview

The reported questions fall into five groups: technical and domain questions about your languages and object-oriented design, system design and architecture, problem-solving cases, coding, and behavioral questions. The coding questions are fundamentals: reversing a string, implementing binary search and solving a dynamic programming problem. With problems this familiar, the differences show in correctness at the boundaries (empty input, a single element, duplicates, integer overflow, multi-byte characters), in stating the complexity without being asked, and in code that runs on the first trace.

The design questions are a mix rather than one theme. One asks for a scalable web application that processes data in real time, one asks what goes into a database schema, and one asks for a project where you traded performance against scalability. That last one is really a story question that needs numbers. So prepare one end-to-end design (ingestion, a partitioned log, stream processing, a serving store, push to clients), one schema walk-through grounded in access patterns, and one measured project story.

The stack in the requirements candidates describe is Python, Java or C++, with Git and JIRA, and Agile or Scrum as the working method. Cloud platforms (AWS, Azure), cybersecurity principles and machine learning or data analysis frameworks are listed as nice-to-haves. Other technical prompts candidates mention include the difference between REST and SOAP APIs and how you keep code quality and maintainability high. Pick the one language you can write without looking anything up, and know its memory and concurrency model well enough to explain it.

The topic breakdown from one reported loop includes CNO Reverse Engineering, CNO (Computer Network Operations) and Programming Fundamentals alongside general software engineering. If your application targets a CNO team, add a low-level refresher to your plan: how C or C++ code lays out the stack and the heap, pointer arithmetic, endianness, reading a hex dump, and the basics of TCP/IP. Treat it as preparation for that team, not as a confirmed round.

The Aquila Technology interview process

These are the stages as candidates describe them. Candidates do not say which questions fall in which stage, so have every question type ready before the Technical Interview.

Resume Submission

Candidates report that the process starts with a resume submission. Nothing else about this stage is reported, so the resume has to carry the screen by itself. Make the languages listed for the role (Python, Java or C++) and your Git and JIRA experience visible in project bullets rather than in a skills list. Each bullet should name what you built, what you tested, how it was deployed and one measurable result. If you have worked on security, networking or analytic tooling, put it near the top, since those match the teams candidates mention.

What to demonstrate

How closely your background matches the languages and tools candidates report for the role
Evidence that you have designed, tested and deployed software, not only written it

How to prepare

Rewrite each project bullet as built / tested / shipped / measured, naming Python, Java or C++ where you used it.
Prepare a two-minute walk-through of the resume, because the reported question about which languages you know best and how you used them asks for exactly that.
List any cybersecurity, cloud (AWS, Azure) or data analysis work separately; candidates see these listed as nice-to-haves.

Email Communication

Candidates report one or more email exchanges after the resume screen, which may include early questions about salary expectations and experience. Handle it like a written screen: answer promptly, keep the reply short and consistent with your resume, and give a researched range rather than a single number if pay comes up. Use the exchange to ask what comes next, because candidates report that some loops continue with an online assessment link and others go straight to a technical interview.

What to demonstrate

Clear, consistent written answers about your experience
Whether your salary expectations and experience match the opening

How to prepare

Write a five-sentence summary of your experience that matches your resume, so email answers stay consistent.
Research a salary range for your level and location before the first reply, and decide on the floor you will accept.
Ask in writing whether the next step is an online assessment or a technical interview, and in which language you may work.

Online Assessment

Candidates report receiving a link to complete an online assessment, or in some loops having a technical interview scheduled instead. The format and content of the assessment are not reported. Since nobody is there to clarify, read every prompt for constraints before you write code, handle the empty and single-element cases explicitly, and run your own tests before you submit. The reported coding questions (string reversal, binary search, a dynamic programming problem) are the right practice set for a self-administered coding format.

What to demonstrate

Completing a self-administered assessment from a link without live clarification
Programming fundamentals in your chosen language

How to prepare

Write binary search, string reversal and two dynamic programming problems from a blank file in your strongest of Python, Java or C++, with no autocomplete.
For each solution, write the edge-case tests first: empty input, one element, duplicates, target outside the range.
State time and space complexity in a comment above each function, so stating it becomes a habit.

Technical Interview

Candidates report a technical interview focused on problem-solving and practical examples. Two kinds of preparation follow. First, think out loud on open problems such as the reported cases on optimising a slow application, testing a feature before deployment and prioritising features: say your first diagnostic step and why before reaching for a fix. Second, ground answers in your own projects: when a concept comes up (object-oriented design, schema design, REST versus SOAP), follow the definition with a place you used it.

What to demonstrate

Structured problem-solving out loud, which candidates name as the focus
Practical examples from your own work, also reported as a focus

How to prepare

Rehearse the slow-application case as a sequence: define slow, reproduce, profile, fix the top bottleneck, verify, guard against regression.
Prepare one project example each for object-oriented design, schema design and a performance trade-off, with numbers.
Practise explaining REST versus SOAP and how you keep code maintainable (reviews, tests, linters, CI on every Git push) in under two minutes each.

Final Interviews

Candidates report final interviews with engineers and team leads that assess fit and capabilities, and say these interviewers value clear communication. Expect both kinds of question here: behavioral stories (team dynamics, persuading a stakeholder, handling feedback, debugging) and technical depth from engineers. Use concrete stories in which your own decisions are visible, and bring specific questions about the team's work, for example how CNO or analytic-tools projects are tested and deployed.

What to demonstrate

Fit with the engineers and team leads candidates report meeting
Technical capability across the areas covered earlier in the loop
Clear communication, which candidates say these interviewers value

How to prepare

Write STAR outlines for the reported behavioral prompts, each with a measurable result and one thing you would change.
Rehearse the real-time web application design end to end, including failure handling, so you can go deep if an engineer asks.
Prepare three questions for the team about its development, testing and deployment practices.

Where candidates lose points

Writing binary search with a mixed invariant, such as while lo < hi with hi = mid - 1, which skips the answer or loops forever on a two-element array.

Commit to one interval convention (closed or half-open), say it aloud, compute mid as lo + (hi - lo) / 2, and trace one-element and two-element arrays before saying you are done.

Jumping into code on the dynamic programming question without stating the state, recurrence, base case and complexity, then getting stuck halfway through the table.

Say the five parts of the recipe before writing a line. Practise coin change, LCS and 0/1 knapsack until you can do this from memory in your interview language.

Debugging and performance stories with no evidence: 'the app was slow, I optimised it' with no baseline, tool or result.

For the debugging question, the slow-application case and the performance-versus-scalability story, prepare the before and after numbers, the profiler or debugger you used, and the test that now guards the fix.

A real-time design that is just boxes and arrows, with nothing on duplicate events, consumer crashes, hot partitions or late data.

For every component in the real-time web application design, say what happens when it fails. Name at-least-once delivery, idempotent writes keyed on event ID, consumer lag monitoring and backpressure.

Behavioral answers told as 'we', so your own decision disappears, or a stakeholder story won by escalation.

Rewrite each STAR outline so every Action sentence starts with 'I'. Pick persuasion stories where the stakeholder had a fair concern and you changed their mind with a prototype, a benchmark or a written comparison.

Questions & practice

Write a function to reverse a string.

Medium · Coding / Algorithms

Approach

Clarify the input: a string or a mutable char array, the expected character set (ASCII or Unicode), and whether in-place is required.
Write the core answer with two pointers: swap s[i] and s[n-1-i] while i < n-1-i. O(n) time, O(1) extra space on a mutable array. Strings are immutable in Java and Python, so copy to a char array or StringBuilder (Java) or use slicing s[::-1] (Python), which is O(n) extra space.
In C++, std::reverse(s.begin(), s.end()) is fine, but show you can write the loop yourself.
Cover edge cases: empty string, one character, null input in Java. Note that reversing UTF-8 bytes in C++ or UTF-16 code units in Java breaks multi-byte characters and surrogate pairs, and combining marks need grapheme-level handling.
Trace the code on 'ab' and 'abc' aloud to show the odd and even lengths both work.

Follow-up

Reverse the order of words in a sentence in place.
Write it recursively. What does that cost in stack space?
How would you reverse a UTF-8 encoded string correctly?

How would you implement a binary search algorithm?

Medium · Coding / Algorithms

Approach

State the precondition: the array is sorted, and say what to return if the target is absent (-1, or the insertion point).
Pick one invariant and stick to it. Closed interval: lo = 0, hi = n-1, while lo <= hi; mid = lo + (hi - lo) / 2 to avoid integer overflow in Java and C++; move lo = mid + 1 or hi = mid - 1. O(log n) time, O(1) space iteratively.
Know the lower-bound variant on a half-open interval [lo, hi) with while lo < hi and hi = mid, which finds the first index whose value is at least the target. This handles duplicates.
Test the edges: empty array, one element, target below the first or above the last element, all elements equal.
Mention that the same idea applies to searching an answer space (the smallest capacity that works) whenever the condition is monotonic.

Follow-up

Find the first and last positions of a target that appears several times.
Search a sorted array that has been rotated at an unknown pivot.
Why can (lo + hi) / 2 fail, and in which languages?

Solve a problem using dynamic programming.

Medium · Coding / Algorithms

Approach

Pick a standard problem and name the two properties that make DP apply: overlapping subproblems and optimal substructure. Coin change (fewest coins for an amount) or longest common subsequence work well.
Follow a fixed recipe: define the state (dp[a] = fewest coins to make amount a), the recurrence (dp[a] = min over coins c <= a of dp[a - c] + 1), the base case (dp[0] = 0, everything else infinity), the iteration order, and where the answer lives.
Give the complexity: O(amount x number of coins) time and O(amount) space; LCS is O(m x n) time and can drop to O(min(m, n)) space with two rolling rows.
Contrast top-down memoisation (natural to write, recursion depth risk) with bottom-up tabulation (no recursion, easier to reduce space), and say which you chose.
Show why greedy fails: with coins {1, 3, 4} and amount 6, greedy takes 4+1+1 (three coins) but 3+3 needs two.

Follow-up

Return the actual coins used, not just the count.
Reduce your 2D table to one dimension. What constraint makes that safe?
Count the number of ways to make the amount instead. What changes in the loop order?

What considerations do you take into account when designing a database schema?

Medium · System Design / Architecture

Approach

Start from access patterns, not tables: list the main reads and writes, their frequency and their latency needs. The schema serves those queries.
Model the entities and relationships: normalise to roughly third normal form to avoid update anomalies, use a join table for many-to-many relationships, then denormalise only where a measured read path needs it.
Enforce integrity in the database: primary keys (surrogate versus natural and why), foreign keys, NOT NULL, UNIQUE and CHECK constraints, and correct data types (timestamps with time zone, decimal for money).
Index for the reported queries: composite index column order follows equality filters first and then range filters. Every index slows writes and costs storage.
Plan for growth and change: partitioning or archiving large time-based tables, migrations that run without locking a live table, and access control or auditing on sensitive columns.

Follow-up

When would you deliberately denormalise, and how do you keep the copies consistent?
How do you add a NOT NULL column to a large table that is serving traffic?
Why might an index on (status, created_at) not be used by a query that filters only on created_at?

Denormalise tenant onto revisions and backfill it live

Hard · denormalisation · online migration · backfill

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

Approach

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

Follow-up

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

What programming languages are you most proficient in, and how have you used them in past projects?

Medium · Technical / Domain Questions

Approach

Name one primary language from the ones listed for the role (Python, Java or C++) and rank the others honestly. Overstating a language you cannot write live backfires once the coding questions start.
For the primary language, give one project in a few sentences: what it did, why that language fit (C++ for memory control and latency, Java for a typed service with mature concurrency libraries, Python for tooling, data processing and glue code), and one result.
Show depth with one internal detail you used: RAII and smart pointers in C++, garbage collection and thread pools in Java, or the GIL and multiprocessing versus asyncio in Python.
Close with how you work in it: testing framework, build tool, Git workflow and code review, since Git appears in the reported requirements.

Follow-up

What class of bug is possible in C++ but not in Java, and how did you guard against it?
Why does Python's GIL matter for a CPU-bound job, and what did you do about it?
If you had to rewrite that project in another of your languages, what would get harder?

Can you explain the concept of object-oriented programming and provide an example of how you implemented it?

Medium · Technical / Domain Questions

Approach

Define OOP in one sentence: modelling a program as objects that bundle state with the behaviour that operates on it. Then name the four principles with one line each: encapsulation, abstraction, inheritance, polymorphism.
Give a real example in your own voice, such as: I defined a Parser interface with one implementation per input format, and the pipeline called parse() without knowing the concrete type, so adding a format meant adding a class rather than editing a switch.
Name the trade-off: deep inheritance hierarchies couple classes tightly, so explain where you chose composition over inheritance and why.
Add one language-specific point: virtual dispatch and the need for a virtual destructor in C++, or interface versus abstract class in Java.

Follow-up

When has inheritance made a codebase harder to change for you?
What happens if a C++ base class with virtual methods has a non-virtual destructor?
How would you unit-test a class that depends on a database connection?

How would you design a scalable web application for real-time data processing?

Medium · System Design / Architecture

Approach

Scope it first: events per second at peak and average, end-to-end latency target, whether ordering matters per entity, retention, and who consumes the results (dashboards, alerts, other services).
Outline the pipeline: stateless ingestion API behind a load balancer; a durable partitioned log such as Kafka, keyed by entity ID so per-entity order holds; stream processors in consumer groups doing windowed aggregation with checkpointed state; a serving store (a time-series or key-value database plus a cache) and push to clients over WebSockets or server-sent events.
State the delivery semantics: at-least-once from the log, so writes downstream must be idempotent (dedupe on event ID, or upsert keyed by entity and window).
Cover scale and failure: add partitions and consumers horizontally; watch consumer lag; apply backpressure or shed load at ingestion; split hot keys; handle late events with event-time windows and watermarks.
Close with security for this kind of data: authentication at ingestion, encryption in transit, and access control on the serving layer.

Follow-up

One sensor produces 50 times more events than the rest. What happens to its partition, and how do you fix it?
A consumer crashes after writing results but before committing its offset. What happens?
How do you handle events that arrive ten minutes late?

Discuss a project where you had to balance performance and scalability.

Medium · System Design / Architecture

Approach

Separate the terms first: performance is how fast one request or job runs; scalability is whether that holds as load, data or users grow. The story needs a point where improving one cost you something on the other.
Give the baseline in numbers (p95 latency, throughput, data size) and the target, so the trade-off is concrete.
Describe the decision: for example, an in-process cache made single requests fast but could not be shared across nodes, so I moved to a shared cache and accepted a network hop; or batching raised throughput but added latency, so I capped batch size.
Show how you measured: a load test or profiler before and after, and the result.
End with what you gave up and what would break first at ten times the load.

Follow-up

What exactly did you measure, and with what tool?
What would fail first if traffic grew ten times?
Looking back, would you make the same trade-off?

You are given a set of requirements for an application. How do you prioritize features?

Medium · Problem-Solving / Case Studies

Approach

Clarify before ranking: who the users are, what the mission or business goal is, the deadline, team capacity, and which requirements are fixed (security, compliance, interfaces to other systems).
Sort with a stated method: must-have versus should/could/won't (MoSCoW), or value against effort, and treat security and regulatory requirements as non-negotiable rather than scoring them.
Order by dependency and risk as well: put the riskiest or most uncertain items early so problems surface while there is time, and define a minimum releasable version.
Keep it visible and revisable: a ranked backlog in a tool such as JIRA, agreed with stakeholders and reviewed each sprint, with the reasoning written down.

Follow-up

Two stakeholders each say their feature is the top priority. What do you do?
A requirement changes mid-sprint. How do you handle it?
How do you estimate effort when the technology is new to the team?

Present a solution to optimize a slow-running application.

Medium · Problem-Solving / Case Studies

Approach

Define slow and measure it: which operation, what latency or throughput, at what percentile, and since when. Then reproduce it in a controlled environment.
Profile before changing anything: a CPU profiler or flame graph (py-spy, perf, VisualVM, async-profiler), and database query plans (EXPLAIN ANALYZE). Find out whether time goes to CPU, I/O, locks, garbage collection or waiting on another service.
Fix the largest bottleneck first. Typical findings: N+1 queries or a missing index, an O(n^2) loop over growing data, synchronous calls that could be batched or parallelised, repeated work that can be cached (with an invalidation plan), memory churn.
Verify with the same benchmark, then guard the gain with a performance test or alert so it does not regress.
State the trade-off of each fix: caching adds staleness, parallelism adds complexity and contention, denormalisation adds write cost.

Follow-up

The profiler shows no hot function, but requests are still slow. What next?
Your cache made it fast but users now see stale data. How do you fix that?
How do you stop this slowdown from coming back after the next release?

How would you approach testing a new feature before deployment?

Medium · Problem-Solving / Case Studies

Approach

Start from the requirements and acceptance criteria, then list the risks: what would hurt most if it broke (data loss, security exposure, a broken interface to another system).
Layer the tests: unit tests for logic and edge cases, integration tests against real dependencies (database, APIs), a few end-to-end tests for the main user flows, plus negative and malformed-input tests for anything exposed.
Automate them in CI so every Git push runs them, and add static analysis and code review before merge.
Before full release: a staging environment that mirrors production config, a feature flag or staged rollout, a rollback plan, and monitoring or alerts on the new code path.
Say what you would not test exhaustively and why, so the plan is proportionate to the risk.

Follow-up

A test fails intermittently in CI. What do you do?
How do you test when staging data does not look like production data?
What do you check in the first hour after release?

Exports duplicate a row range about once a week

Hard · leases · clock skew · idempotency

Roughly once a week an export writes a file containing a duplicated range of rows. The affected job_run rows show attempt = 1, status = succeeded, one started_at, and a lease_owner naming a different host from the one whose logs show the job starting. Leases last 30 seconds and are heartbeated every 10 from inside the handler; lease_expires_at is computed on the worker and compared against the database's now(). Find the mechanism, and give a fix that holds even if you cannot fix the clocks.

Approach

Start from the fact that eliminates the obvious answer. attempt = 1 means no retry was recorded, so this is not a re-run after failure; two workers ran the same row concurrently and the takeover path never touched the counter. lease_owner naming a host other than the one that started the job is the same statement from the other side.
Enumerate the mechanisms that cause a premature takeover, then find the signal that separates them. Either the lease genuinely expired because the heartbeat did not fire, which is what happens when the heartbeat runs on the handler's own thread and the handler makes a long blocking call, or it only appeared expired because two clocks disagree, since lease_expires_at is written from the worker's clock and evaluated against the database's. The discriminator is the distribution: incidents clustered on the longest exports indict the heartbeat, incidents clustered on one host indict skew. Measure both, and measure each host's offset against the database directly.
Read the reclaim query precisely. In PostgreSQL now() is transaction start time, not statement time, so a reclaimer holding a long transaction compares against an older timestamp than expected; clock_timestamp() is the statement-time function. This is worth ruling in or out before you redesign anything, because it changes which rows look expired.
Remove the second clock rather than trying to synchronise it. Issue and extend the lease in the database, with lease_expires_at = now() + interval '30 seconds' in both the claim and the heartbeat, so exactly one clock is ever compared and worker skew stops mattering to this predicate.

Follow-up

The displaced worker has already streamed half the file to object storage. What makes that side effect safe to repeat?
You now count takeovers. What alert fires on that counter, and at what threshold?

Suggested practice checklist

Each day targets one group of reported questions and the stage where that skill matters, moving from the resume and email screen through coding fundamentals and design to the behavioral finals.

Day 1 — Resume, email screen and your language answer

Rewrite every resume bullet as built / tested / shipped / measured, naming Python, Java or C++ and Git where you used them.
Write your answer to the question about which languages you know best: one primary language, one project, one internal detail (memory model, GC or GIL).
Research a salary range and write a five-sentence experience summary for the email stage.

Deliverable: A revised resume, a spoken two-minute language answer, and a written salary range plus experience summary.

Day 2 — Coding fundamentals: strings and binary search

Write string reversal in your interview language three ways (two pointers on an array, built-in, recursive) and test empty, one-character and Unicode inputs.
Write binary search with a closed interval and lower bound with a half-open interval from a blank file, with edge-case tests.
Solve first-and-last occurrence and search in a rotated sorted array.

Deliverable: A tested file with string reversal, two binary search variants and two follow-up problems, each with its complexity commented.

Day 3 — Dynamic programming from a fixed recipe

Solve coin change bottom-up, write out state, recurrence, base case, order and answer, then reconstruct the coins used.
Solve longest common subsequence, then reduce it to two rolling rows.
Solve 0/1 knapsack, and explain aloud why greedy fails on coins {1, 3, 4} for amount 6.

Deliverable: Three solved DP problems, each with a one-paragraph recipe and its time and space complexity.

Day 4 — Object-oriented design and domain questions

Write a short OOP example from your own work (an interface with several implementations), with the composition-versus-inheritance trade-off.
Write two-minute answers on REST versus SOAP and on how you keep code maintainable (reviews, tests, CI on every Git push).
If you are targeting a CNO team, review stack and heap layout, pointers, endianness and reading a hex dump in C or C++.

Deliverable: A spoken OOP answer with a code sample, two two-minute domain answers, and low-level notes if relevant.

Day 5 — Design: real-time pipeline and schema

Sketch the real-time web application end to end: ingestion, partitioned log, stream processing, serving store, push to clients, then list one failure mode per component.
Design a schema for a small domain from its access patterns: keys, constraints, a join table and composite indexes, with one deliberate denormalisation.
Work the practice question on denormalising a tenant column onto revisions and backfilling it on a live table.
Write the performance-versus-scalability project story with baseline and result numbers.

Deliverable: One design diagram with failure notes, one schema with index choices, a live-backfill plan, and a measured project story.

Day 6 — Problem-solving cases

Rehearse the slow-application case as a spoken sequence: define, reproduce, profile, fix, verify, guard.
Write a test plan for a feature you shipped: unit, integration, end-to-end, negative tests, CI, staging, feature flag, rollback.
Prioritise a ten-item requirement list with MoSCoW and dependencies, and explain the order aloud.
Work the practice debugging question on exports that duplicate a row range about once a week.

Deliverable: Three spoken case answers and a written debugging walk-through for the export duplication problem.

Day 7 — Behavioral stories and a full mock

Write STAR outlines for the debugging, team dynamics, stakeholder persuasion and feedback questions, with every Action sentence in the first person.
Record yourself answering each in about two minutes and cut any sentence that does not show your own decision.
Run a mock: one coding problem from days 2-3, the real-time design, and two behavioral stories back to back.

Deliverable: Four STAR outlines, four recorded answers, and a list of weak spots from the mock.

Behavioural preparation

Candidates report that the final interviews with engineers and team leads assess fit as well as capability, and that these interviewers value clear communication. The reported behavioral questions cover team dynamics on a hard project, persuading a stakeholder, handling feedback and debugging. Each needs a specific story with your own actions and a result.

Give an example of a time when you had to learn a new technology quickly to complete a project.
Discuss a time when you had to navigate a conflict within a team.

Describe a time when you had to debug a complex software issue. What was your approach?

Medium · Technical / Domain Questions

Approach

Choose a bug that was hard for a technical reason (race condition, memory corruption, a production-only failure, data-dependent behaviour), not one that was hard only because the code was unfamiliar.
Structure it as STAR, but put most of the time into the sequence: how you reproduced it, how you narrowed it (logs, git bisect, a minimal repro, binary-chopping the input), each hypothesis and the evidence that ruled it in or out.
Name the tools you used: a debugger such as gdb or an IDE debugger, AddressSanitizer or Valgrind for memory faults, a profiler, packet captures or extra logging.
Finish with the root cause as opposed to the symptom, the fix, the regression test you added, and what you changed so the class of bug is caught earlier.
What sinks this answer: a fix found by luck, or a story that ends at 'restarted it and it went away'.

Follow-up

How did you know you had fixed the root cause and not just hidden the symptom?
What test or alert now catches this kind of bug?
If you could not reproduce it locally, what would you have done next?

Describe a challenging project you worked on. How did you manage the team dynamics?

Medium · Behavioral / Leadership

Approach

Pick a project that was hard because of people, not only technology: unclear ownership, a disagreement about approach, a deadline squeeze or a skill gap on the team.
Use STAR with a short Situation and a long Action. Say what you did: one-on-one conversations, splitting work along clear interfaces, writing a short decision record, changing the meeting cadence.
Give a measurable or concrete outcome (shipped on a date, defects down, the conflict resolved) and what the team does differently now.
Speak in the first person about your own actions. What sinks this answer: blaming a teammate, or a story told entirely as 'we' in which your own role disappears.

Follow-up

What would you have done if that teammate's behaviour had not changed?
How did you keep the delivery date while resolving it?
What did your lead think of how you handled it?

Tell me about a time when you had to persuade a stakeholder regarding a technical decision.

Medium · Behavioral / Leadership

Approach

Open with the stakeholder's real concern (cost, schedule, risk or operational burden), because a persuasion story only works if the other side had a reasonable position.
Show the evidence you brought: a small prototype, a benchmark, a written comparison of options with risks, or a failure from production that made the case.
Show the movement: what you conceded, what compromise or staged rollout you offered, and how the decision was finally made and recorded.
Finish with the outcome and how you know the decision was right (or what you learned if it was not). What sinks it: winning by escalation or authority, or a story where the stakeholder simply looks foolish.

Follow-up

Tell me about a time you failed to persuade someone. What happened?
How did you explain the technical risk to someone non-technical?
What would you have done if they had still said no?

How do you handle feedback from peers or supervisors?

Medium · Behavioral / Leadership

Approach

Answer with a specific piece of critical feedback, not a general attitude: for example, a code review that said my error handling hid failures, or a lead telling me my status updates came too late.
Show the response sequence: I asked clarifying questions, separated the substance from the delivery, changed something concrete, and followed up to check the change was noticed.
Show the lasting effect: a habit, checklist or practice you still use.
Add one line on giving feedback, since peers are named in the question. What sinks this answer: 'I always welcome feedback' with no example, or a trivial example.

Follow-up

Tell me about feedback you disagreed with. What did you do?
How do you handle a long disagreement in a code review?
How do you give critical feedback to someone more senior?