The role as candidates describe it is general software engineering with a cloud and data flavour. Day to day that means designing and building applications, sitting in code reviews, working out requirements with product and QA colleagues, and debugging problems in running software. The question list mirrors that spread: language and tooling questions, a handful of design questions, problem-solving scenarios, behavioral prompts and a small set of classic algorithm questions.
The technical material is broad rather than deep. The reported coding questions are a palindrome check, finding two numbers that add up to a target, comparing depth-first and breadth-first search, optimizing a shortest-path solution, and stating time and space complexity. Each of these has a standard answer, so the work is fluency: write it cleanly in your strongest language, name the complexity without being asked, and list the edge cases (empty input, duplicates, disconnected graph, negative weights) before they come up.
The design and problem-solving questions are open-ended: a system for a high volume of data transactions, a cloud-based application, an API for a new service, microservices, database design, a project that is falling behind and a sudden change in specifications. Strong answers are anchored in something you have done. Pick two or three real projects and prepare to describe the schema, the API contract, the deployment, the tests and the failures from each, so that every open question has a concrete example behind it.
The last round is described as conversations with potential team members about collaboration. The behavioral prompts that candidates report (conflict, prioritizing, mentoring, motivation, feedback, learning a technology quickly) are best prepared as a small set of stories that you can reshape, each with your own decision and a result you can state.
Screening Interview
reportedCandidates describe the Screening Interview as the first stage, a conversation that checks basic qualifications and fit for the role. The requirements candidates describe list Java, C# or Python, cloud platforms and data architecture, Agile or Scrum, Git and automated testing, so expect to be asked to place your own experience against that list. Prepare a short, factual walkthrough of your background: the languages you are strongest in and why, one or two projects with your specific part in them, and how your teams ran the development lifecycle.
What to demonstrate
- Whether your experience lines up with the role's listed requirements
- How clearly you can summarize your own background and projects
- Basic fit for a Software Engineer position
How to prepare
- Write a short answer to "What programming languages are you most proficient in, and why?" that names a language, a project you used it on and one trade-off you know first-hand
- Prepare your answer on the software development lifecycle and your experience with it, anchored to one real project and one team process such as Scrum
- Make a one-page inventory of your Git workflow, testing frameworks and cloud or data work so that you can answer from it without searching for examples
Technical Assessments
reportedCandidates describe Technical Assessments as an evaluation of technical capability through coding challenges and problem-solving questions. The coding questions candidates report are classic: a palindrome function, two numbers that sum to a target, depth-first versus breadth-first search, and shortest-path optimization, along with discussing time and space complexity. The problem-solving questions are scenarios such as developing a solution from requirements or troubleshooting software issues. Work the coding set in your strongest language until you can write each solution cleanly, say its complexity and list its edge cases without prompting.
What to demonstrate
- Working code for a coding challenge
- The way you break a problem down and justify your choices
- Whether you can state time and space complexity and trade-offs
- Debugging and troubleshooting approach on scenario questions
How to prepare
- Write the palindrome check and the two-sum solution from memory, including the hash-map version of two-sum, and say the complexity of each
- Write iterative breadth-first and depth-first search on an adjacency list, then explain when each fits and which one finds shortest paths in an unweighted graph
- Practise the design prompts out loud: a high-volume transaction system, a cloud-based application, an API for a new service, and when microservices help or hurt
- Rehearse a troubleshooting sequence: reproduce, check what changed, narrow with logs and bisection, confirm the cause, add a test
Team Discussions
reportedCandidates describe Team Discussions as conversations with potential team members about cultural fit and collaboration. This is where the behavioral prompts candidates report belong: resolving a conflict, prioritizing across projects, mentoring a colleague, handling feedback and learning a technology quickly. Prepare stories where you made a decision and can state the result, and prepare your own questions about how the team works day to day.
What to demonstrate
- Collaboration and communication with future teammates
- Cultural fit, as the round is described
- How you describe conflict, feedback and mentoring from your own experience
How to prepare
- Prepare four or five stories that cover conflict, prioritization, mentoring, feedback and learning something quickly, and note which prompts each one can answer
- For every story, write down your own action, the outcome and what you would change, so "I" carries the answer rather than "the team"
- Prepare questions about the team's code review, testing and release routine, so the conversation can go both ways
PracHub editorial advice for the preparation topics above.
Answering the lifecycle, microservices or cloud questions with textbook definitions and no project behind them
For each of these questions, prepare one real system you worked on, and state what you chose, what it cost and what you would change. A definition only starts the answer.
Starting to code the two-sum or palindrome problem before checking the input and the edge cases
Ask about empty input, case and punctuation for the palindrome, and duplicates or no valid pair for two-sum. Mention the brute-force version, then write the hash-map or two-pointer solution and say its complexity.
Leaving time and space complexity unstated, even though discussing complexity is itself one of the reported questions
Say the complexity of every function you write as you finish it: O(n) time and O(n) space for the hash-map two-sum, O(V+E) for breadth-first search, O((V+E) log V) for Dijkstra with a heap.
Giving vague tool answers such as "Git and Jira" when asked about version control and project management
Describe the workflow: branching model, pull-request review, how CI runs your automated tests, how tickets map to sprints. Concrete practice is more convincing than a tool list.
Telling team stories in the first person plural, so your own decision is invisible in conflict, mentoring and prioritization answers
Write each story with your action in the middle: what you said, what you decided, what changed. Keep the team context in one sentence and state the result in numbers or observable change where you can.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
Write a function to determine if a string is a palindrome.
Write a function to determine if a string is a palindrome.
Approach
- Clarify the rules first: case sensitivity, whether spaces and punctuation are ignored, and that an empty or one-character string counts as a palindrome.
- Use two pointers: left at 0, right at n-1, compare and move inward until they meet; with the 'ignore non-alphanumeric' rule, skip such characters on each side and compare lowercased characters. This runs in O(n) time with O(1) extra space.
- Contrast the one-liner (compare the string with its reverse, s == s[::-1] in Python): also O(n) time, but it allocates an O(n) copy and cannot stop early at the first mismatch.
- Test edge cases aloud: empty string, all punctuation, even and odd lengths, mixed case such as 'A man, a plan, a canal: Panama'.
- Mention Unicode limits: in Java and C# a char is a UTF-16 code unit, so characters outside the Basic Multilingual Plane (emoji) span two chars and need code-point iteration to compare correctly.
Follow-up
- Return true if the string can become a palindrome after deleting at most one character.
- How would you check whether a singly linked list is a palindrome in O(1) extra space?
- Find the longest palindromic substring: what is your complexity?
Given an array of integers, find two numbers that add up to a specific target.
Given an array of integers, find two numbers that add up to a specific target.
Approach
- Confirm the contract: return indices or values, exactly one answer or possibly none, whether the same element may be used twice, and whether the array is sorted.
- State the brute force (check every pair) at O(n^2) time and O(1) space, then improve it.
- Use a hash map from value to index in one pass: for each x, check whether target - x is already in the map before inserting x. This is O(n) average time and O(n) space, and checking before inserting stops an element pairing with itself while still handling duplicates such as [3, 3] with target 6.
- If the array is sorted, two pointers from both ends give O(n) time and O(1) space; sorting first costs O(n log n) and loses original indices unless you sort (value, index) pairs.
- Cover edge cases: no valid pair, negative numbers, and integer overflow in Java or C# when computing target - x near the int limits (use long).
Follow-up
- Return all unique pairs that sum to the target, without duplicates.
- Extend it to three numbers that sum to zero: what is the best complexity you can reach?
- What changes if the numbers arrive as a stream too large to hold in memory?
Explain the difference between a depth-first search and a breadth-first search algorithm.
Explain the difference between a depth-first search and a breadth-first search algorithm.
Approach
- BFS explores level by level with a FIFO queue; DFS goes as deep as possible along one branch before backtracking, using recursion or an explicit stack.
- Both visit each vertex and edge once with an adjacency list, O(V + E) time; with an adjacency matrix they are O(V^2). Both need a visited set on graphs with cycles, and BFS should mark a node visited when it is enqueued to avoid duplicate entries.
- BFS finds the shortest path by number of edges in an unweighted graph and suits nearest-first searches; its memory grows with the widest level.
- DFS suits cycle detection, topological sort, connected components, path existence and backtracking problems; its memory grows with depth, and deep recursion can overflow (Python's default recursion limit is 1000), so switch to an iterative stack on large graphs.
- Pick by the question: 'fewest steps' points to BFS, 'explore every configuration' or 'order by dependencies' points to DFS.
Follow-up
- Why does BFS not give the shortest path once edges have different weights?
- How would you detect a cycle in a directed graph with DFS?
- What is iterative deepening DFS, and when does it beat plain BFS?
How would you optimize a solution for finding the shortest path in a graph?
How would you optimize a solution for finding the shortest path in a graph?
Approach
- Pick the algorithm from the graph's properties: unweighted, BFS in O(V + E); non-negative weights, Dijkstra with a binary heap in O((V + E) log V); negative edges, Bellman-Ford in O(VE), which also detects negative cycles; a DAG, relax edges in topological order in O(V + E).
- Optimise Dijkstra in practice: stop as soon as the target is popped from the heap, use lazy deletion (skip heap entries whose distance is stale) instead of decrease-key, and store parent pointers to rebuild the path.
- For a single source and target on a large graph, use bidirectional search or A* with an admissible heuristic (one that never overestimates, such as straight-line distance on a map) to explore far fewer nodes.
- Use special cases when they apply: 0-1 BFS with a deque for edge weights of only 0 or 1 in O(V + E); Floyd-Warshall in O(V^3) for all-pairs on small dense graphs.
- For many repeated queries on a static graph, trade memory for speed by precomputing or caching distances, and say what that costs when the graph changes.
Follow-up
- Why can Dijkstra return a wrong answer when a graph has negative edge weights?
- How do you return the path itself, not only its length?
- The graph does not fit in memory on one machine: what changes?
Discuss the time and space complexity of your proposed solutions.
Discuss the time and space complexity of your proposed solutions.
Approach
- State complexity in named input sizes (n elements, V vertices and E edges, m and n for two inputs) and give time and space separately, counting auxiliary space and the recursion stack.
- Distinguish worst, average and amortized cases: a hash map lookup is O(1) on average but O(n) in the worst case with heavy collisions; appending to a dynamic array (ArrayList, List, Python list) is amortized O(1) even though an occasional resize copies everything.
- Watch hidden costs in library calls: repeated string concatenation in a loop can be O(n^2) because strings are immutable in Java, C# and Python (use StringBuilder or join), slicing a Python list copies O(k), and comparison sorting is O(n log n) at best in the worst case.
- Tie each choice to a trade-off: for example, two-sum moves from O(n^2) time and O(1) space to O(n) time and O(n) space by spending memory on a hash map.
- Sanity-check with input limits: roughly 10^8 simple operations is a practical ceiling for a quick run, so n = 10^5 rules out O(n^2) but allows O(n log n).
Follow-up
- Explain why appending to a dynamic array is amortized O(1).
- When would you accept a slower algorithm to save memory?
- What is the space complexity of a recursive DFS on a path-shaped graph with n nodes?
Replace offset paging on the resource feed with keyset
resource holds resource_id, tenant_id, owner_user_id, title, body_ref, version, status ('draft','active','archived','deleted'), created_at, updated_at, deleted_at, with an index on (tenant_id, status, updated_at DESC, resource_id DESC). The listing endpoint returns active resources for one tenant, newest update first, 50 per page, today with LIMIT 50 OFFSET n. Tenants reach page 400 and rows are created while they read. Write the keyset query, define what the cursor carries and how it is encoded, and say which part of the index each predicate uses. Assume PostgreSQL 16.
Approach
- Name the two failures separately. OFFSET 20000 makes the server produce and discard 20,000 rows, so page cost grows with depth rather than with page size. Independently, any write that changes how many rows sort above the offset moves the window between two fetches, and the direction decides which anomaly you get: an insert lands at the head of updated_at DESC and pushes already-returned rows down past the boundary, so they are returned a second time; a delete above the offset, or a row whose updated_at is bumped above the cursor, pulls rows up and one is never returned at all. Nothing in the response reveals either.
- Write the seek: WHERE tenant_id = $1 AND status = 'active' AND (updated_at, resource_id) < ($2, $3) ORDER BY updated_at DESC, resource_id DESC LIMIT 50. The row-value comparison is one index range rather than a disjunction, and both columns are NOT NULL, which is what makes that comparison well defined.
- Map each predicate onto the index: tenant_id and status are equality on the leading columns, (updated_at, resource_id) is the range, and the ORDER BY matches the index order so no Sort node appears and the scan stops after 50 rows. The DESC in the definition only matters for mixed directions — a plain ascending btree on the same columns is read backwards for this query.
- Put both sort columns in the cursor and nothing the client can tamper with into another tenant: base64 of (updated_at, resource_id), validated server-side, with tenant_id taken from the principal.
Follow-up
- The client asks for 'jump to page 400'. What do you offer instead, and what does the honest version cost?
- Sort order becomes user-selectable across four columns. How many indexes is that, and which would you refuse to add?
Write the update path that detects a concurrent edit
resource carries version INT NOT NULL DEFAULT 1. resource_revision holds revision_id, resource_id, version, actor_user_id, change_kind, patch JSONB, request_id, created_at with UNIQUE (resource_id, version). outbox_event holds aggregate_type, aggregate_id, aggregate_version, event_type, payload, status. A PUT carries the version the client read. Write the exact statements for the single transaction that applies the edit, records the revision and enqueues 'resource.updated', and give the handler's branch on zero affected rows. Then say what PostgreSQL 16 does under READ COMMITTED when two of these updates hit one row at once.
Approach
- One transaction, three writes, no network call inside it: UPDATE resource SET title = $3, version = version + 1, updated_at = now() WHERE resource_id = $1 AND tenant_id = $4 AND version = $2; then INSERT the resource_revision row at version $2 + 1; then INSERT the outbox_event row at the same aggregate_version. The event goes to a table rather than a broker because no transaction spans both.
- Branch on the affected-row count before doing anything else. Zero has three causes — stale version, wrong tenant, row gone — so re-read once and map to 409 carrying the current version, or 404 for an id outside the caller's tenant, which also stops the endpoint confirming that another tenant's id exists.
- State the engine behaviour instead of assuming it. Under READ COMMITTED the second UPDATE blocks on the row lock, and when the first commits PostgreSQL re-evaluates the WHERE clause against the newly committed row, so the version predicate now fails and the statement reports zero rows. Under REPEATABLE READ the identical collision raises SQLSTATE 40001 instead, so the handler must fold both shapes into one conflict response.
- Keep UNIQUE (resource_id, version) even though the predicate already serialises writers. It is what makes a lost update unwritable if any other path ever reaches the revision table, and it converts a logic bug into 23505 rather than into a silently missing history row.
Follow-up
- A client sends the version it read ten minutes ago and the resource has moved three versions. What is in your 409 so it can resolve the conflict without a full re-fetch?
- Two editors, two disjoint fields, no overlap. Does your answer still refuse the second write, and should it?
What programming languages are you most proficient in, and why?
What programming languages are you most proficient in, and why?
Approach
- Lead with one or two languages you have shipped production code in, and line them up against the requirements candidates describe for this role (Java, C# or Python) instead of listing everything you have touched.
- Back each claim with evidence: the system you built, its rough size, and the language features you used every day (Java generics and streams, C# async/await and LINQ, Python generators, type hints and context managers).
- Explain the 'why' as trade-offs: static typing and compile-time checks in Java and C# against faster iteration in Python; managed memory with garbage collection in all three; ecosystem fit (Spring, .NET, the Python data stack).
- Be calibrated about depth: say where you are expert (debugging, profiling, the standard library) and where you are working knowledge, so follow-up questions land where you are strong.
Follow-up
- When would you pick Python over Java or C# for a new service, and when would you refuse to?
- What is one feature of your strongest language that you avoid in production code, and why?
- How do memory management and concurrency differ between two of the languages you named?
Describe a challenging technical problem you solved and the approach you took.
Describe a challenging technical problem you solved and the approach you took.
Approach
- Choose a problem with a concrete, measurable symptom (latency spike, data corruption, failing integration) where you personally drove the diagnosis and the fix.
- State the constraints up front in one or two sentences: production impact, deadline, what you could and could not change.
- Walk the reasoning in order: the hypotheses you formed, the evidence that eliminated each (logs, profiler output, a reproduction), and the root cause you landed on.
- Name the fix and its trade-off (for example, an added index that sped up reads but slowed bulk writes), then give the measured result before and after.
- Close with prevention: the regression test, alert or design change you added so the same failure cannot return silently.
Follow-up
- What alternative fix did you reject, and why?
- How did you confirm your change caused the improvement rather than coinciding with it?
- What would you do differently if you met the same problem today?
How do you ensure code quality and maintainability in your projects?
How do you ensure code quality and maintainability in your projects?
Approach
- Describe layered automated tests: fast unit tests on business logic, integration tests against real dependencies (database, message broker) in CI, and a small set of end-to-end checks; name the testing framework you use (JUnit, xUnit or NUnit, pytest).
- Gate merges in CI: build, tests, linters and static analysis must pass on every pull request; treat coverage as a signal for untested paths, not a target to game.
- Explain your code review practice: small pull requests, a reviewer who checks naming, error handling, test cases and edge cases, and comments that explain why rather than what.
- Cover design for maintainability: single-responsibility modules, dependency injection so code is testable, removing duplication only once a pattern repeats, and refactoring only with tests in place.
- Mention documentation that ages well: a README that gets a new developer running, and short decision records for choices that would otherwise be re-argued.
Follow-up
- How would you add tests to a legacy module that has none before changing it?
- What do you do when a deadline pushes the team to skip tests?
- How do you tell whether a codebase is getting harder to maintain over time?
What tools do you use for version control and project management?
What tools do you use for version control and project management?
Approach
- For version control, name Git (the requirements candidates describe list it) and your branching model: trunk-based development with short-lived feature branches, or GitFlow with release branches, and why that model fit your release cadence.
- Show working fluency: protected main branch with required reviews and CI checks; merge versus rebase (rebase rewrites history, so never rebase a branch others have pulled); git revert to undo a pushed commit safely; git bisect to binary-search the commit that introduced a regression.
- For project management, describe how work flowed through your Agile or Scrum process: a groomed backlog, sprint planning, a definition of done that includes tests and review, and commits or pull requests linked to tickets.
- Name the specific tools you used (for example Jira or Azure Boards, GitHub or GitLab) and one concrete way you made them reduce friction, such as a pull-request template or automated ticket transitions.
Follow-up
- A bad commit is already on main and others have pulled it: how do you undo it?
- When would you choose merge commits over squash or rebase merges?
- How do you resolve a merge conflict in a file two people changed for different reasons?
How would you design a system to handle a high volume of data transactions?
How would you design a system to handle a high volume of data transactions?
Approach
- Clarify the workload before drawing anything: transactions per second at peak, read/write ratio, record size, whether each transaction must be atomic and durable (money-like) or can tolerate eventual consistency, and the latency target.
- Outline the write path: stateless API instances behind a load balancer, an idempotency key on each request so a client retry cannot apply a transaction twice, and a relational database with connection pooling and indexes matched to the access pattern.
- Scale writes by partitioning on a key that keeps each transaction on one shard (for example account id); name the cost, which is that cross-shard queries and transactions become expensive, and watch for hot keys.
- Absorb bursts and decouple downstream work with a durable queue or log; use the transactional outbox pattern so the database write and the published event cannot diverge, and make consumers idempotent because delivery is at least once.
- Scale reads separately with read replicas or a cache, stating where replica lag or cache staleness is acceptable and where reads must hit the primary.
Follow-up
- How do you handle a transaction that must touch two shards?
- One partition key receives most of the traffic: what do you change?
- How do you guarantee each queued transaction is processed exactly once in effect?
What considerations would you take into account when designing a cloud-based application?
What considerations would you take into account when designing a cloud-based application?
Approach
- Availability: run stateless compute across multiple availability zones behind a load balancer with health checks and autoscaling; keep session state out of the instances (in a cache or database).
- Data: choose managed databases or storage, enable automated backups, test restores, and state recovery targets (RPO for how much data you may lose, RTO for how long you may be down).
- Security: least-privilege IAM roles, secrets in a secrets manager rather than in code or config files, encryption in transit (TLS) and at rest, and private networking for databases.
- Operations: infrastructure as code so environments are reproducible, CI/CD with blue-green or canary deployments and quick rollback, and observability through logs, metrics, traces and alerts tied to user-facing symptoms.
- Cost: right-size instances, scale down off-peak, use storage lifecycle rules, and tag resources so spend is attributable to a service.
Follow-up
- What happens to your application if a whole region becomes unavailable?
- How do you rotate a database credential without downtime?
- How would you find out which component is driving a sudden rise in the cloud bill?
Discuss how you would approach designing an API for a new service.
Discuss how you would approach designing an API for a new service.
Approach
- Start from the callers and use cases, then model resources as nouns (/orders, /orders/{id}) with HTTP methods that keep their semantics: GET is safe, PUT and DELETE are idempotent, POST is not, so accept an Idempotency-Key header on creates.
- Write the contract first in an OpenAPI specification so clients and server can be built and tested against it in parallel; validate requests at the edge.
- Design errors as carefully as success: 400 for malformed input, 401 versus 403, 404, 409 for state conflicts, 429 with Retry-After for rate limits, and a consistent error body with a machine-readable code.
- Handle collections and concurrency: cursor (keyset) pagination that stays stable while data changes, filtering and sorting parameters, and ETag with If-Match so a stale update gets 412 instead of overwriting.
- Plan versioning and security from day one: additive changes stay backward compatible, breaking changes go to a new version (path or header) with a deprecation window, and authentication via tokens such as OAuth 2.0 with per-scope authorization.
Follow-up
- A client times out on a create call and retries: what does your API do?
- How would you roll out a breaking change to a field that existing clients depend on?
- Why might offset pagination return duplicate or missing items, and how does a cursor fix it?
Can you explain the importance of microservices architecture?
Can you explain the importance of microservices architecture?
Approach
- Define it plainly: an application split into independently deployable services, each owning one business capability and its own data, communicating over the network through APIs or events.
- Give the benefits with conditions: independent deployment and release cadence, scaling only the hot service, fault isolation, and team ownership aligned with service boundaries (Conway's law).
- Give the costs just as concretely: network latency and partial failure, no cross-service ACID transactions (so sagas and eventual consistency), distributed tracing and logging, and much more deployment and operational overhead.
- Name the patterns that make it workable: API gateway, service discovery, timeouts with retries and exponential backoff, circuit breakers, and correlation ids for tracing.
- State when you would not use it: a small team or an unclear domain is often better served by a modular monolith that can later be split along proven boundaries using the strangler fig pattern.
Follow-up
- How would you split an existing monolith without a big-bang rewrite?
- An order must update inventory and billing in two services: how do you keep them consistent?
- How do you trace a single slow request across five services?
Given a set of requirements, how would you approach developing a solution?
Given a set of requirements, how would you approach developing a solution?
Approach
- Separate functional requirements (what the system does) from non-functional ones (load, latency, availability, security, compliance), and list the open questions you would take back to stakeholders before building.
- Turn each requirement into testable acceptance criteria, then prioritise (for example MoSCoW) so the must-haves are explicit.
- Sketch the design: data model, main components and interfaces, and the riskiest assumption; prototype or spike that risk first.
- Deliver a thin vertical slice end to end early, then iterate in Agile increments with tests and code review, showing working software to stakeholders to catch misunderstandings.
- Plan verification and operation: the test strategy at each level, how the feature is deployed and monitored, and how you will know it meets the non-functional targets.
Follow-up
- Two requirements contradict each other: how do you resolve it?
- How do you estimate the work when the requirements are still vague?
- What would you build first, and why that slice?
Describe how you would handle a project that is falling behind schedule.
Describe how you would handle a project that is falling behind schedule.
Approach
- Quantify the gap first: remaining work against observed velocity or a burn-down chart, so the conversation is about numbers rather than impressions.
- Find the cause before the cure: underestimation, scope creep, a blocked dependency, unplanned support work or a technical surprise each needs a different fix.
- Lay out options with their costs: reduce scope to the must-haves, resequence to ship the core first, remove blockers, or move the date; note that adding people late often slows a project further (Brooks's law) because of ramp-up and coordination cost.
- Communicate early to stakeholders with the options and a recommendation, and do not quietly cut testing or code review to recover time, since that moves the cost into production.
- After delivery, run a short retrospective and adjust estimation or planning so the same slip is visible sooner next time.
Follow-up
- The stakeholder rejects both a scope cut and a date change: what do you do?
- Which early signals tell you a project is slipping before the deadline is close?
- How would you decide whether to add another engineer?
How would you address a sudden change in project specifications from stakeholders?
How would you address a sudden change in project specifications from stakeholders?
Approach
- Understand the reason behind the change and who owns the decision before reacting; a change driven by a regulation or customer commitment is handled differently from a preference.
- Do an impact analysis: affected code, data model and migrations, tests, integrations and timeline, and present it with options (absorb it, swap it for lower-priority scope, or move the date).
- Record the change through the team's process: update the backlog, acceptance criteria and documentation so the agreed version is not lost in a chat thread.
- Implement in a way that limits risk: feature flags to ship behind a toggle, backward-compatible schema changes using expand then contract migrations, and tests that encode the new behaviour.
- Reduce the cost of future changes: shorter feedback loops with stakeholders and a design that isolates volatile rules behind clear interfaces.
Follow-up
- The change arrives in the middle of a sprint: how do you handle it?
- Two stakeholders ask for conflicting changes: who decides, and how?
- The old behaviour is already in production with stored data: how do you migrate it safely?
What strategies do you employ to troubleshoot software issues?
What strategies do you employ to troubleshoot software issues?
Approach
- Define the symptom precisely and reproduce it: exact error, affected users or inputs, when it started, and whether it is consistent or intermittent.
- Ask what changed (deploys, configuration, dependency versions, data volume or shape) and line it up with the start time from logs and metrics.
- Narrow the search systematically: read stack traces and correlated logs, use tracing across services, bisect commits with git bisect or toggle feature flags, and change one variable at a time.
- For intermittent or production-only issues, suspect concurrency, timeouts, resource exhaustion (connections, memory, file handles) or environment differences, and add targeted logging with correlation ids instead of guessing.
- Fix the root cause rather than the symptom, add a regression test, confirm with the same metric that showed the problem, and write up what happened for the team.
Follow-up
- The bug happens in production but you cannot reproduce it locally: what next?
- How do you tell a real cause from something that merely coincided with the failure?
- When would you roll back rather than fix forward?
The plan follows the three reported rounds: screening answers first, then coding and design for the technical assessments, then the stories for the team discussions. Each day produces something you can write or say out loud.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the loop and write your screening answers
- Write the three reported rounds on one page and mark which of them you are least ready for.
- Make an inventory of your languages, projects, Git workflow, testing frameworks and cloud or data experience, against the Java, C#, Python, cloud and data architecture requirements candidates describe.
- Say aloud your answers on the languages you are most proficient in and on the software development lifecycle, each tied to a real project.
Deliverable: A one-page loop map, a one-page experience inventory and recorded spoken answers on languages and the lifecycle.
Practice prompt ↗Practice prompt ↗02Coding fluency: strings, arrays and complexity
- Write the palindrome function in your best language, handling case, punctuation and empty input, with a two-pointer version.
- Write two-sum with a hash map and with brute force, and say why the map version is O(n) time and O(n) space.
- Practise stating the time and space complexity of each solution as you finish it.
Deliverable: Working palindrome and two-sum functions with test cases and a written complexity line for each.
Practice prompt ↗Practice prompt ↗Practice prompt ↗03Graph search and shortest paths
- Write breadth-first and depth-first search iteratively on an adjacency list, and recursively for depth-first.
- Write a short explanation of when each is the right choice: shortest path in an unweighted graph, cycle detection, connected components.
- Extend to weighted graphs: Dijkstra with a heap, why it fails with negative weights, and where Bellman-Ford or A* fit.
Deliverable: Three working graph functions (BFS, DFS, Dijkstra) plus a half-page comparison of when to use each.
Practice prompt ↗Practice prompt ↗04Design: transactions, cloud, APIs and microservices
- Outline a design for a high volume of data transactions: ingestion, queueing, idempotent writes, storage and what happens when a dependency is down.
- Write a checklist of considerations for a cloud-based application: scaling, failure handling, configuration, security, cost and deployment.
- Design an API for a new service (resources, versioning, error responses, retries) and write a balanced answer on when microservices help and when they add cost.
Deliverable: Four short design outlines, each with components, a trade-off and a failure case.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗05Database design, code quality and tooling
- Write up the schema you know best: entities, keys, indexes tied to real queries, constraints and a migration you ran.
- Work through PracHub's practice questions on keyset paging and detecting a concurrent edit, to sharpen the database side.
- Write your answers on code quality and maintainability (review, tests, CI, static analysis) and on version control and project management tools, with your own workflow.
Deliverable: A schema write-up with an index plan, two completed practice exercises and written answers on code quality and tooling.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗06Problem-solving scenarios and troubleshooting
- Write out how you turn a set of requirements into a solution: clarify, list assumptions, split into milestones, decide how to test.
- Prepare answers for a project falling behind schedule and for a sudden change in specifications: re-scope, communicate and re-plan.
- Rehearse a troubleshooting sequence on a real incident you handled, and pick the challenging technical problem you will describe.
Deliverable: Five spoken answers (requirements, schedule slip, spec change, troubleshooting, challenging problem), each with one real example.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗07Team discussion stories and full run-through
- Write your stories for conflict, prioritization, mentoring, feedback and learning a technology quickly, with your own action and the result in each.
- Answer the motivation prompt with two concrete moments and a link to the work in the role.
- Do a full spoken run: one coding question, one design question and two stories, then note the weakest answer and fix it.
Deliverable: A set of five written stories, a motivation answer and a recorded full run-through with the weakest answer marked.
Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Practice prompt ↗Expand any day for tasks and deliverables. Your progress is saved on this device.
Candidates describe the final round as conversations with potential team members about collaboration and cultural fit. The reported prompts cover conflict, prioritizing, mentoring, motivation, feedback and learning quickly, all from a Software Engineer's day: code review, shared deadlines and changing requirements. Build a small set of stories that each show your own decision and a result, and practise telling them in first person.
Can you explain the software development lifecycle and your experience with it?
Can you explain the software development lifecycle and your experience with it?
Approach
- Name the phases once (requirements, design, implementation, testing, release, maintenance), then move quickly to the project where you lived them. Define the model your team used, for example Scrum sprints with backlog refinement, or a more sequential plan, and why it suited that work.
- Say what you owned at each stage: writing acceptance criteria with the product owner, breaking work into tickets, code review, automated tests in CI, release steps, and on-call or bug triage afterwards.
- Include one point where the lifecycle failed, such as a requirement that arrived late or a defect found in production, and say which step you changed afterwards (added a regression test, tightened review, split the release).
- Do not recite textbook phases with no project behind them; the question asks about your experience, so every phase you mention should have something you did.
Follow-up
- Where in that lifecycle did most of your defects originate, and how did you know?
- How would the process change for a two-person team compared with a larger one?
- Tell me about a release that went wrong and what you changed afterwards.
How do you handle database design in your applications?
How do you handle database design in your applications?
Approach
- Walk through the database you know best as a real design: the main entities, the keys, the relationships (one-to-many, many-to-many through a join table) and why you normalized to roughly third normal form before denormalizing anything.
- Tie indexes to queries: name the two or three queries that mattered, the composite index you built for them, and how you confirmed the plan with EXPLAIN rather than guessing.
- Cover integrity and change: foreign keys, unique and check constraints, how migrations ran without breaking the running application, and which operations needed a transaction (and at what isolation level).
- Name one trade-off you accepted, for example a denormalized counter for read speed, a JSON column for flexible attributes, or a relational store for transactions and a different store for a feed, and the cost you took on.
- Mention concurrency if you handled it: optimistic locking with a version column, or a unique constraint to make a retry safe.
Follow-up
- When did you denormalize, and how did you keep the copies consistent?
- How would you add a non-null column to a large table with no downtime?
- How do you decide between a relational database and a document store for a new service?
Describe a time when you had to resolve a conflict within your team.
Describe a time when you had to resolve a conflict within your team.
Approach
- Pick a real disagreement with a peer, not a villain: a technical one such as an API shape, a framework choice or how to split a service works well because the resolution can rest on evidence.
- Use situation, action and result, and spend most of the answer on actions: you asked the other person to state their goal, found the criteria you both accepted (latency, maintenance cost, deadline), and settled it with a prototype, a measurement or a written comparison.
- State the outcome and the relationship afterwards, including a point where you changed your own position if you did; this shows you resolved the conflict rather than won it.
- Avoid blaming the other person, describing a manager's ruling as your resolution, or choosing an example where nothing was at stake.
Follow-up
- What if the other person had been more senior than you?
- Was there a point where you decided they were right?
- What would you have done if you had not reached agreement before the deadline?
How do you prioritize tasks when working on multiple projects?
How do you prioritize tasks when working on multiple projects?
Approach
- Give your method first: list every commitment, note the deadline and who is waiting on it, estimate effort, and rank by impact and cost of delay, with dependencies that block other people moved up.
- Then show it on one real stretch when two projects competed, for example a production bug during a sprint: what you chose to do first, what you deferred and why.
- Describe the communication, which is the part that gets skipped: you told the affected stakeholders what would slip, agreed a new date and recorded it in the sprint backlog or ticket.
- Mention how you protect focus (blocking time, batching reviews) and how you notice you are overcommitted before a deadline is missed.
- Avoid answers that amount to "I work harder" or "everything is a priority"; the answer should show a choice and its cost.
Follow-up
- Two stakeholders both insist their request is urgent; what do you do?
- How did you handle a task you had said yes to and then had to drop?
- How do you re-plan when an urgent bug lands mid-sprint?
Provide an example of how you mentored a colleague in your previous roles.
Provide an example of how you mentored a colleague in your previous roles.
Approach
- Choose one colleague and state the starting gap in a sentence (a junior new to the codebase, someone moving from another language, a peer struggling with testing), then the goal you set with them.
- Describe the methods: pairing on a real ticket, code review comments that explain why instead of only what, a stretch task with a safety net, and progressively stepping back so they owned the next change.
- Show a result you can observe, such as their first independent release, fewer review round trips or a design they presented, and attribute it to their work and your support.
- Say what you learned as a mentor; avoid stories where you did the work for them or where the only outcome is that they liked you.
Follow-up
- What did you do when they did not follow your advice?
- How do you write a review comment that teaches without discouraging?
- How did you know when to stop helping?
What motivates you to succeed in your job?
What motivates you to succeed in your job?
Approach
- Answer with evidence, not slogans: two or three concrete moments when you were most engaged, such as getting a hard bug to a root cause, shipping something users relied on or growing a teammate.
- Find the pattern across them (for example, problems with a clear user effect, or work that improved a team's habits) and connect it to what the role involves as candidates report it: building, maintaining and debugging software with product and QA colleagues.
- Be honest about what drains you, since a believable answer has a boundary; make it a working condition, not a complaint about people.
- Avoid answers built only on pay or title, and avoid claims about the company's mission that you cannot support from the role description.
Follow-up
- Tell me about a time your motivation dropped and what you did about it.
- What kind of work would you turn down?
- How do you stay motivated on maintenance work with little visibility?
How do you handle feedback and criticism of your work?
How do you handle feedback and criticism of your work?
Approach
- Pick one real piece of critical feedback you received, ideally from a code review or a retrospective, where the criticism was fair and specific.
- Describe your first reaction briefly and honestly, then what you did: asked a clarifying question, restated what you heard, checked the evidence and changed your approach (a new review checklist, more tests, smaller pull requests).
- Close the loop: go back to the person later and show the change, and state the visible result such as fewer review comments of that kind.
- Include how you deliver feedback yourself, since the team discussion covers collaboration both ways; avoid a fake weakness such as "I work too hard".
Follow-up
- Tell me about feedback you disagreed with and how you handled it.
- How do you give a peer feedback on code they are proud of?
- What is the most useful comment a reviewer has left on your work?
Discuss a time when you had to learn a new technology quickly to complete a project.
Discuss a time when you had to learn a new technology quickly to complete a project.
Approach
- Set the scene with the deadline and the gap: the technology (a framework, cloud service or language new to you), why the project needed it and what was at risk if you got it wrong.
- Describe a learning plan rather than "I read the docs": a small spike to test the core idea, official documentation for the parts you would actually use, reading an existing service's code, and asking one experienced colleague for a review of your first version.
- Show how you kept risk down: tests written as you learned, a small first slice shipped behind a flag or in a non-critical path, and an early check-in when you hit a limit.
- State the outcome and what you could do afterwards that you could not before; do not claim you knew everything, and avoid stories where someone else did the work.
Follow-up
- How did you know you had learned enough to ship?
- What did you get wrong at first?
- How do you decide between learning a tool and using one you already know?
- 01
Can you explain the software development lifecycle and your experience with it?
- 02
How do you handle database design in your applications?
- 03
Describe a time when you had to resolve a conflict within your team.
- 04
How do you prioritize tasks when working on multiple projects?
- 05
Provide an example of how you mentored a colleague in your previous roles.
- 06
Discuss a time when you had to learn a new technology quickly to complete a project.
How many interview rounds does Citizant have for a Software Engineer?
Candidates report three stages: a Screening Interview, Technical Assessments and Team Discussions. The screening covers basic qualifications and fit, the technical stage covers coding challenges and problem-solving questions, and the final stage is conversations with potential teammates about collaboration.
Citizant Software Engineer candidate reports ↗How long does the Citizant process take?
Candidates report roughly 3-5 weeks across the three rounds. Scheduling varies, so use the waiting time between stages to practise the next one: coding and design for the technical stage, stories for the team discussions.
Citizant Software Engineer candidate reports ↗What coding problems do candidates report for Citizant?
The reported coding questions are a palindrome function, finding two numbers that add up to a target, the difference between depth-first and breadth-first search, optimizing shortest-path solutions, and discussing time and space complexity. Practise writing each in your strongest language and saying its complexity and edge cases aloud.
Citizant Software Engineer candidate reports ↗Which languages and technologies should I prepare?
The requirements candidates describe for the role name Java, C# or Python, cloud platforms and data architecture, Agile and Scrum, Git, and testing frameworks with automated testing. DevOps practices and user experience design are listed as nice to have. Use the language you know best for the coding questions and prepare real examples for cloud, data, Git and testing.
Citizant Software Engineer candidate reports ↗How should I prepare for the design questions?
The reported design prompts are a system for high-volume data transactions, a cloud-based application, an API for a new service, microservices and database design. Prepare one real system from your own work and an outline for each prompt covering components, data model, failure handling and one trade-off. Day 4 and day 5 of the plan are built for this.
Citizant Software Engineer candidate reports ↗What should I prepare for the Team Discussions round?
Prepare stories for conflict, prioritizing, mentoring, feedback and learning a new technology quickly, each with your own action and a result. Also prepare questions about how the team reviews code, tests and releases, so the conversation about collaboration goes both ways.
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.
- 01Citizant 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.
Together Ai Software Engineer Interview Guide
Failure-handling practice for Together Ai 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.
Lambda Software Engineer Interview Guide
Failure-handling practice for Lambda 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.
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.