Ziphq Software Engineer
Interview Guide

• Write a short background summary, plus one line each for work authorisation or sponsorship, start date, location and competing timelines, and plan to raise sponsorship in the recruiter screen.
• Pick one interview language and commit to it. List the standard-library calls you look up most (sorting with a comparator, heaps, deques, default dictionaries, string split and join) and drill them until you no longer need to look them up.
• Write the questions you will ask the recruiter about the technical assessments: platform, allowed languages, and whether a later round uses a provided codebase.

Deliverable: A one-page screen sheet: background summary, constraints, language choice and questions for the recruiter.

• Implement preorder, postorder and level-order traversal of an n-ary tree, each one recursively and with an explicit stack or queue, and test on an empty tree, a single node and a deep chain.
• Solve maximum non-adjacent sum on an n-ary tree. For each node, return two values in one post-order pass: include = the node's value plus the sum of every child's exclude value, and exclude = the sum, over all children, of the larger of each child's two values. The answer is the larger of the root's two values, in O(n) time.
• Given parent-child ID pairs, find the root IDs (nodes that never appear as a child) and the path from a root to any node using a parent map.

Deliverable: Six traversal functions and two tree problems, each with its complexity written above the code and the edge-case inputs used to test it.

• Solve shortest path on an infinite grid with obstacles using BFS. Explain how you bound the search (for example, a one-cell margin around the bounding box of obstacles, start and target) and what changes when barriers appear or move over time.
• Work one medium-to-hard dynamic programming problem. Write the state, the transition and the base case in words before any code, then cut memory to rolling rows if each row depends only on the previous one.
• Write one backtracking solution with pruning and state its branching factor and maximum depth.
• Pair with someone on one graph traversal problem and narrate the whole time, as practice for the reported pair-programming format.

Deliverable: Three solved problems (grid shortest path, DP, backtracking) with the search bound or DP state written out, plus notes from the paired session on where you went quiet.

• Build an in-memory key-value store in stages: set, get and delete first, then per-key expiry checked against a supplied timestamp, then value history that can be queried by time. Write the tests for each stage before its code.
• Model a vending machine or a payment processor as classes. Name each class's responsibility, the state it owns and the errors it raises. Then add one new requirement and note whether it forced changes outside a single class.
• Complete one full practice assessment in a browser-based editor, and pass every provided test before you refactor.

Deliverable: A staged key-value store with tests for each stage, one domain model with a written list of class responsibilities, and a record of which practice-assessment tests failed and why.

• In a small backend project you did not write, add an endpoint that follows the existing routing, validation and error-handling patterns, with a unit test for the success case and one failure case.
• Extend an existing function to handle a new edge case or input type. Write a test that fails before your change and passes after it.
• Break a test on purpose, then debug it as you would in the interview: state the input, expected value and actual value before editing, and fix the root cause rather than the assertion.
• Work through the debugging drill on a log partition that stops advancing, writing your ordered checks before you read the approach.

Deliverable: One review-ready change in an unfamiliar codebase (new endpoint, extended feature, fixed test), each part with its own test.

• Take a brute-force O(n^2) solution, such as a pair search or an interval overlap check, and bring it to O(n log n) with sorting, a heap or binary search. Write down which step removed the extra factor.
• Refactor a snippet for memory: replace a materialised list with a streaming pass, or a full DP table with rolling rows, and measure peak memory before and after.
• Complete the worked coding exercise on finding the heaviest tenants: size-k min-heap extraction and the memory cost of the exact structure.
• Complete the worked design exercise on replication lag, then practise stating the scalability trade-off of your chosen approach in two or three sentences.

Deliverable: Two optimised solutions with before-and-after complexity, one measured memory refactor, and written answers to both worked exercises.

• For two projects you owned, write the problem, your role, two decisions with the alternatives you rejected, and the result. Rehearse each at a short length and a detailed length.
• Prepare STAR stories for a challenging project you owned end to end, a technical disagreement (including one across teams), prioritising conflicting deadlines, and learning a new technology or domain quickly.
• Run a mock live-coding session on a tree or graph problem with a partner who stays mostly quiet. Narrate, dry-run a sample input, and ask for feedback when you are stuck.
• Explain the worked SQL exercise on holding a per-tenant cap under concurrent creates out loud, as practice for describing a race and its fix.

Deliverable: Two project write-ups, four STAR stories, and notes from the mock session on where you paused or skipped the dry run.