cswork / libraryOpen practice workspace

Interview guides · Knowledge Excel Services

Knowledge Excel Services Software Engineer Interview Guide

Knowledge Excel Services Software Engineer interview guide: reported rounds, questions and how candidates describe the process.

The 60-second brief

A Software Engineer at Knowledge Excel Services plays a pivotal role in bridging the gap between complex data processing and actionable business intelligence. As the company operates heavily within the market research and analytical space, your technical contributions directly impact the efficiency of data pipelines, the reliability of client-facing platforms, and the speed at which the organization delivers insights. This role is both technically demanding and strategically significant. You will not merely be writing code; you will be architecting solutions that handle the nuance of market research data. Whether you are optimizing front-end performance for data visualization or ensuring the integrity of back-end database systems, your work serves as the foundation for the firm’s competitive advantage.

This guide is scoped to a Software Engineer candidate at Knowledge Excel Services.

Focus areas

  • DOM Visibility: display vs visibility
  • Database Management System (DBMS)
  • JavaScript (JS)

The Knowledge Excel Services interview process

Knowledge Excel Services candidates report 7 rounds over 4-6 weeks. The stages below are what candidates describe, not a published process.

Initial Technical Assessment

Candidates undergo initial technical assessments to evaluate their basic programming principles.

What to demonstrate

  • Candidates undergo initial technical assessments to evaluate their basic programming principles
  • Depth in DOM Visibility: display vs visibility

How to prepare

  • Answer aloud and timed: Difference between visibility hidden and display none?
  • Answer aloud and timed: How do you handle cross-browser compatibility in CSS?

Manager-led Evaluation

Deeper evaluations led by managers to assess both technical skills and soft-skill alignment.

What to demonstrate

  • Deeper evaluations led by managers to assess both technical skills and soft-skill alignment
  • Depth in DOM Visibility: display vs visibility

How to prepare

  • Answer aloud and timed: Explain the event loop in JavaScript.
  • Answer aloud and timed: How do you optimize a query in a relational database?

Aptitude Tests

Candidates participate in aptitude tests that challenge their quick thinking and problem-solving abilities.

What to demonstrate

  • Candidates participate in aptitude tests that challenge their quick thinking and problem-solving abilities
  • Depth in DOM Visibility: display vs visibility

How to prepare

  • Answer aloud and timed: Explain the difference between primary keys and foreign keys.
  • Answer aloud and timed: What has been your best interest in programming languages and why?

Live Technical Problem-Solving

Engagement in live technical problem-solving sessions to demonstrate practical application of skills.

What to demonstrate

  • Engagement in live technical problem-solving sessions to demonstrate practical application of skills
  • Depth in DOM Visibility: display vs visibility

How to prepare

  • Answer aloud and timed: Walk me through a challenging technical project you led.
  • Answer aloud and timed: How would you estimate the number of smartphones in a city?

Written Testing

Completion of written tests to further evaluate technical knowledge and analytical mindset.

What to demonstrate

  • Completion of written tests to further evaluate technical knowledge and analytical mindset
  • Depth in DOM Visibility: display vs visibility

How to prepare

  • Answer aloud and timed: Solve the following logic puzzle: [Common brain teaser pattern].
  • Work DOM Visibility: display vs visibility until you can explain it without notes

Group Interactions

Potential group interactions to assess teamwork and collaborative skills.

What to demonstrate

  • Potential group interactions to assess teamwork and collaborative skills
  • Depth in DOM Visibility: display vs visibility

How to prepare

  • Work DOM Visibility: display vs visibility until you can explain it without notes
  • Work Database Management System (DBMS) until you can explain it without notes

Final Technical and Behavioral Assessments

Final evaluations focusing on both technical expertise and behavioral fit for the company.

What to demonstrate

  • Final evaluations focusing on both technical expertise and behavioral fit for the company
  • Depth in DOM Visibility: display vs visibility

How to prepare

  • Prepare three examples from your own work, each with a decision you made and an outcome you can quantify.
  • Re-read the description of the final technical and behavioral assessments above and write down what you would ask to confirm before it.

Where candidates lose points

Structure your answers

When asked about a project, use the STAR method (Situation, Task, Action, Result) to keep your response focused and impactful.

Research the company

Knowledge of the specific market research domain will show you are serious about the mission of Knowledge Excel Services.

Don't fear the "grill

If an interviewer pushes you on a technical point, stay calm and explain your reasoning. They are often testing your confidence in your own knowledge.

Master the basics

Do not neglect foundational topics like Database Management Systems or basic web styling, as these are frequent points of questioning.

Questions & practice

Canonicalise a request body into a stable idempotency fingerprint

Medium · parsing · canonicalisation · hashing

idempotency_key.request_fingerprint is a SHA-256 over the method, path and canonicalised body, and a retry whose fingerprint differs must be rejected with 422 rather than served the stored response. Write the canonicaliser. Bodies are JSON up to 256 KB nested at most 32 levels; clients vary key order, whitespace and unicode escaping, and some send 64-bit ids as JSON numbers. Produce a deterministic byte string such that semantically identical bodies match and any semantic difference does not. State your complexity and name two normalisations you refuse to perform.

Approach

  1. Parse once into a tree, then re-serialise under fixed rules: object keys sorted, array order preserved, one escaping convention, no insignificant whitespace. Parsing is O(n) and sorting keys is O(k log k) per object, so O(n log n) overall with O(depth) stack, and the 32-level cap is enforced during parsing because hostile nesting is how a canonicaliser becomes a stack overflow.
  2. Sort keys by their UTF-8 bytes and say why the obvious implementation is wrong in some runtimes: a default string comparison that orders by UTF-16 code units places surrogate pairs, meaning code points from U+10000 up, below U+E000 to U+FFFF, which is not UTF-8 byte order, so two services written in different languages disagree on the same document.
  3. Do not re-encode numbers through a double. IEEE-754 binary64 represents integers exactly only up to 2^53, so normalising a 19-digit id through a float changes it, and 1 against 1.0 cannot be reconciled without deciding whether they are the same value. Preserve the literal token, and require ids as strings at the API boundary if you want them comparable.
  4. Reject duplicate keys rather than picking one. JSON permits them and parsers disagree, most keeping the last, so any choice you make ties the fingerprint to a parser detail that the code handling the request does not necessarily share.

Follow-up

  • A client sends the same logical request with an extra field your API ignores. Same key, different fingerprint, so you return 422. Is that the right answer?
  • Where does the fingerprint get computed relative to request decompression and the body-size limit?

Find overlapping job attempts and peak concurrency from lease records

Medium · sweep line · intervals · leases

A day of job_run history yields about 50,000,000 attempt records: (job_run_id, job_type, attempt, started_at, finished_at which is NULL when the worker died, lease_expires_at). Leases expire on a clock, so a job that outran its lease ran twice. Produce (a) every job_run_id whose attempts overlapped in wall-clock time and (b) the peak number of simultaneously running attempts per job_type with the minute it occurred. Target O(n log n). State how you treat a NULL finished_at and what clock skew does to your answer.

Approach

  1. Define the interval before sorting anything: an attempt occupies [started_at, COALESCE(finished_at, lease_expires_at)). finished_at is observed and lease_expires_at is only a promise, so every attempt without a finish contributes an estimate and the whole result is a lower bound on overlap rather than an exact count.
  2. For peak concurrency, sweep: emit 2n endpoints, sort by (timestamp, kind) with ends ordered before starts at equal timestamps, then walk the sequence maintaining a counter per job_type and record each type's maximum with its timestamp. O(n log n) dominated by the sort, O(n) space, or O(1) extra if the sort is external and the walk streams.
  3. For overlap detection, do not compare attempts pairwise. A single global sort by (job_run_id, started_at) gives both the grouping and the order; within a group, keep the maximum end seen so far and report an overlap exactly when the next start is less than that running maximum, which is one linear pass after the sort.
  4. Half-open intervals matter and are easy to get wrong: with closed intervals an attempt ending at the same millisecond another begins reads as concurrency two, and across 50,000,000 records that artefact swamps the real signal.

Follow-up

  • A handler is not idempotent and you have found 400 overlapping jobs. Which of them actually caused damage, and what would you query to find out?
  • Peak concurrency for one job_type is 4 against a configured cap of 4. Is the cap working, or is the data hiding attempts that never started?

Track a rolling failure rate per destination for circuit decisions

Easy · sliding window · ring buffer · circuit breaker

The egress service delivers about 1,500 webhooks per second across roughly 40,000 destinations, each call bounded by a 10 second timeout. Maintain, per destination, the failure rate over the trailing 60 seconds so a caller can ask before dispatch whether the circuit should open. Attempts arrive as (destination_id, finished_at_ms, outcome). Requirement: amortised O(1) per attempt, with total memory bounded by the destination count rather than by traffic. Give the structure, its exact memory, and the rule that stops a destination with three attempts from opening a circuit.

Approach

  1. Name the exact-deque version and then reject it as the default. Holding timestamps and advancing a tail pointer past anything older than now minus 60 seconds is a correct two-pointer window at amortised O(1) per attempt, but its memory tracks in-window traffic, so one destination in a retry storm holds hundreds of thousands of entries while thousands of quiet destinations hold none.
  2. Use a ring of 60 one-second buckets per destination, each bucket a pair of counters for attempts and failures. On an attempt, advance the ring by the elapsed whole seconds, zeroing at most min(elapsed, 60) buckets, then increment the head. That is amortised O(1) with a fixed footprint per destination.
  3. State the footprint: 60 buckets times two 4-byte counters is 480 bytes of payload per destination, so 40,000 destinations is roughly 20 to 25 MB with per-entry overhead, bounded by the catalogue rather than by the rate. The cost is granularity, since the oldest bucket ages out in whole seconds, which is far tighter than the decision needs.
  4. Require a minimum sample before the circuit may open. A destination with three attempts and three failures reads as 100 percent and is not evidence; a floor of roughly 20 attempts in the window makes the ratio meaningful, and below that floor use a run of consecutive failures as the trigger instead.

Follow-up

  • The fleet is 30 instances and each sees roughly a thirtieth of a destination's traffic. Where does the rate actually live, and what does a per-instance answer get wrong?
  • A destination answers in 9.5 seconds and succeeds. It is not failing but it is consuming your per-destination concurrency. What signal should open the circuit here?

How do you optimize a query in a relational database?

Medium · Technical Depth and Database Management

Approach

  1. Name the grain you start from and join outward from it.
  2. Check whether any join is one-to-many before aggregating, or the sums inflate.
  3. Say which index the query would use, and what makes it unusable.
  4. Handle the rows that do not match: that is usually the actual question.

Follow-up

  • How does the query change if that join becomes one-to-many?
  • What happens to this when the table is ten times larger?

Replace offset paging on the resource feed with keyset

Easy · keyset pagination · composite index · sort order

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

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

Difference between visibility hidden and display none?

Medium · Front-End Fundamentals

Approach

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

Follow-up

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

Explain the event loop in JavaScript.

Medium · Front-End Fundamentals

Approach

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

Follow-up

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

Explain the difference between primary keys and foreign keys.

Medium · Technical Depth and Database Management

Approach

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

Follow-up

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

What has been your best interest in programming languages and why?

Medium · Technical Depth and Database Management

Approach

  1. Say who the caller is and what they do when the call fails halfway.
  2. Define the identity of a request so a retry cannot double-apply it.
  3. Separate accepted, pending, failed and confirmed; they are different facts.
  4. Design the error taxonomy before the success shape; callers branch on it.

Follow-up

  • What happens if the caller retries after a timeout?
  • How does a client discover it is on an old version of this contract?

Walk me through a challenging technical project you led.

Medium · Problem-Solving and Logic

Approach

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

Follow-up

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

How would you estimate the number of smartphones in a city?

Medium · Problem-Solving and Logic

Approach

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

Follow-up

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

Solve the following logic puzzle: [Common brain teaser pattern].

Medium · Problem-Solving and Logic

Approach

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

Follow-up

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

Read latency spikes on a sixty-second sawtooth

Medium · cache stampede · single-flight · ttl

The cached listing read path serves about 14k reads/second at an 85% hit rate. p99 sits at 35 ms for 57 seconds, jumps to 900 ms for 3, and repeats. During each spike the primary shows several hundred identical listing queries starting within the same millisecond, all carrying one large tenant's id. Cache entries use a 60-second TTL. Give the mechanism, the ordered checks, the fix, and the correctness hazard your fix must not introduce.

Approach

  1. Match the period to a configured number before theorising about load. A spike every 60 seconds against a 60-second TTL is an entry expiring, and you confirm it by correlating spike timestamps with the entry's write time rather than with the traffic curve. If the period had matched a cron or a GC interval instead, this is a different investigation.
  2. Establish the concurrency of the miss. Several hundred identical queries in one millisecond means the miss path has no coalescing: every request that arrives between expiry and repopulation recomputes. The herd size is that key's arrival rate times its recompute time, so at 1.2k reads/second for the hot key and a 250 ms recompute you expect about 300 concurrent misses, which matches what is observed.
  3. Add single-flight on the miss path so one caller per key recomputes under a short-lived lock while the rest wait for its result. Prefer stale-while-revalidate where the read tolerates it: return the expired value immediately and refresh asynchronously, which removes the latency spike rather than serialising it into a queue of waiters.
  4. De-synchronise the keys. Write TTLs with jitter, for example 60 seconds plus or minus 10%, so a deploy or a mass invalidation does not align every key on the same second and turn a per-key herd into a fleet-wide one.

Follow-up

  • The same sawtooth appears on a key that is invalidated on write rather than expired. Is that the same bug?
  • How does your answer change if the recompute takes 4 seconds instead of 250 ms?

Suggested practice checklist

Built from the rounds and topics Knowledge Excel Services candidates report.

Day 1 — Map the Knowledge Excel Services loop

  • Write out the reported sequence: Initial Technical Assessment, Manager-led Evaluation, Aptitude Tests, Live Technical Problem-Solving, Written Testing, Group Interactions.
  • For each round, write one sentence on what it is judging, from the description above, and mark the one you are least ready for.

Deliverable: A one-page map of the 7 reported rounds, with the weakest marked.

Day 2 — Work DOM Visibility: display vs visibility

  • Spend the session on DOM Visibility: display vs visibility, which Knowledge Excel Services candidates report being tested on.
  • Write one worked example in DOM Visibility: display vs visibility and time yourself on it.

Deliverable: One timed worked example in DOM Visibility: display vs visibility.

Day 3 — Work Database Management System (DBMS)

  • Spend the session on Database Management System (DBMS), which Knowledge Excel Services candidates report being tested on.
  • Write one worked example in Database Management System (DBMS) and time yourself on it.

Deliverable: One timed worked example in Database Management System (DBMS).

Day 4 — Work JavaScript (JS)

  • Spend the session on JavaScript (JS), which Knowledge Excel Services candidates report being tested on.
  • Write one worked example in JavaScript (JS) and time yourself on it.

Deliverable: One timed worked example in JavaScript (JS).

Day 5 — Answer out loud: Front-End Fundamentals

  • Answer aloud, timed: Difference between visibility hidden and display none?
  • Answer aloud, timed: How do you handle cross-browser compatibility in CSS?

Deliverable: Spoken answers to 2 reported Front-End Fundamentals question(s), under time.

Day 6 — Answer out loud: Technical Depth and Database Management

  • Answer aloud, timed: How do you optimize a query in a relational database?
  • Answer aloud, timed: Explain the difference between primary keys and foreign keys.

Deliverable: Spoken answers to 2 reported Technical Depth and Database Management question(s), under time.

Day 7 — Answer out loud: Problem-Solving and Logic

  • Answer aloud, timed: Walk me through a challenging technical project you led.
  • Answer aloud, timed: How would you estimate the number of smartphones in a city?

Deliverable: Spoken answers to 2 reported Problem-Solving and Logic question(s), under time.

Behavioural preparation

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

How do you handle cross-browser compatibility in CSS?

Medium · Front-End Fundamentals

Approach

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

Follow-up

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

Reverse your own decision and price the reversal

Medium · reversibility · measurement · migrations

Describe a technical decision you made and later reversed. Pick one that cost something: a service you split and merged back, a cache you added and removed, an index you created that pushed the planner onto a worse plan, a projection you rebuilt from scratch. State what you believed when you decided, the measurement that changed your mind, how long the wrong version ran in production, and what the reversal cost in migrations, dual writes, and a deprecation window for callers you did not own.

Approach

  1. State the original rationale without irony, in the version you would still defend given what was known then. If it is not defensible, the story is about carelessness rather than judgement, and a different example serves you better.
  2. Give the measurement that moved with a before and after: the p99 that did not improve, the cache hit rate that sat at 40%, the plan that flipped to a sequential scan once the table passed a size you can name.
  3. Cost the reversal in steps, not adjectives: expand-and-contract deploys, the dual-write window, the callers who had to be notified, the rows already written in the wrong shape that had to be backfilled or abandoned.
  4. Distinguish reversal from rewrite by naming what you kept. Most good reversals preserve the schema or the interface and undo one decision inside it, which is also why they were affordable.

Follow-up

  • What in that decision was irreversible, and did you know it was irreversible when you made it?
  • How did you tell the people who had already built on top of the original decision?

Unblock an engineer without taking the keyboard

Easy · mentoring · leases · at-least-once

A teammate has spent two days on a job handler that occasionally writes duplicate rows. They are certain the queue is delivering twice by mistake. You suspect a lease expiring under a slow handler, so the job is running concurrently with itself. Describe how you have unblocked someone in this position: what you asked before offering a hypothesis, what you showed them rather than told them, and what you left them owning. Then say what you would do if their theory turned out to be the right one.

Approach

  1. Ask before diagnosing, and ask for things answerable from data they already have: the attempt count on the job rows that produced duplicates, the handler's observed duration against its lease expiry, and whether the duplicate rows share a natural key that a unique constraint could have caught.
  2. Teach the shape rather than the answer. A lease cannot distinguish a dead worker from a slow one, so a handler that outruns its lease is running twice by design, and deploys deliver the other half by killing handlers mid-run on every rollout. Both of their candidate theories produce identical duplicate rows, which is why the evidence has to come from timings rather than from argument.
  3. Hand over a checklist they execute: a natural key on every write the handler performs so the second copy collides rather than appends, the record of intent written before any external effect, a lease heartbeat while running, and the metric that shows it working.
  4. Keep ownership with them deliberately. Pair on the first write, then step back; if you finish it yourself you have closed one ticket and left the same person stuck on the next redelivery.

Follow-up

  • How would you distinguish a genuine double-delivery from a lease expiry using only the data already stored?
  • Their handler calls an external endpoint before recording that it did. What do you tell them to change first?