Scalable Press Software Engineer Interview Guide

The 60-second brief

As a Software Engineer at Scalable Press, you are at the intersection of complex logistics and high-scale software development. The company operates in a fast-paced environment where software directly powers physical production and supply chain workflows. Your work is critical to maintaining the efficiency, reliability, and scalability of their printing and fulfillment platforms. You will be expected to contribute to a codebase that demands high performance and architectural rigor. Whether you are optimizing algorithmic throughput for order processing or building robust system architectures, your contributions have a direct, tangible impact on the business. This role is ideal for engineers who thrive on solving difficult technical puzzles and who are comfortable working in an environment that values both precision and speed.

This guide is scoped to a Software Engineer candidate at Scalable Press.

Focus areas

• Time Complexity Analysis (Big O notation)
• Algorithms (general)
• Data Structures

The Scalable Press interview process

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

Recruiter Screen

Initial screening by a recruiter to evaluate your background and fit for the role.

What to demonstrate

• Initial screening by a recruiter to evaluate your background and fit for the role
• Depth in Time Complexity Analysis (Big O notation)

How to prepare

• Be able to walk your CV end to end in two minutes, and say why this company specifically.
• Have your salary expectations, notice period and location constraints ready, and ask for the rest of the loop in writing.

Technical Interviews

A series of phone or video interviews with engineers and managers focusing on technical skills.

What to demonstrate

• A series of phone or video interviews with engineers and managers focusing on technical skills
• Depth in Time Complexity Analysis (Big O notation)

How to prepare

• Answer aloud and timed: Given an array of integers, return an array that contains all possible permutations of the initial values.
• Answer aloud and timed: How would you use a HashMap to optimize a search or processing task?

Technical Assessments

Candidates may complete coding challenges or participate in system design conversations.

What to demonstrate

• Candidates may complete coding challenges or participate in system design conversations
• Depth in Time Complexity Analysis (Big O notation)

How to prepare

• Answer aloud and timed: Explain the difference between various data structures and when to choose one over another.
• Answer aloud and timed: Explain Javascript scope and the behavior of callbacks.

Onsite Interview

Final interview where candidates meet multiple team members to assess technical skills and cultural fit.

What to demonstrate

• Final interview where candidates meet multiple team members to assess technical skills and cultural fit
• Depth in Time Complexity Analysis (Big O notation)

How to prepare

• Answer aloud and timed: How do you approach layout problems using CSS Flexbox or Grid?
• Answer aloud and timed: What are your preferred methods for scripting repetitive tasks?

Where candidates lose points

Talk through your code

Even if you are confident in your solution, walk your interviewer through your logic. This helps them understand how you think.

Prepare for the "Why

Be ready to explain why you chose a particular data structure or architectural approach. Trade-offs are a part of engineering, and you should be able to defend yours.

Know your resume

Be prepared to discuss any project on your resume in depth, including the challenges you faced and how you overcame them.

Ask meaningful questions

Use the time at the end of the interview to ask about the team’s current technical challenges or the company’s long-term engineering vision.

Questions & practice

How do you measure the performance of an algorithm?

Medium · Technical Fundamentals and Algorithms

Approach

1. Restate the input: its shape, its size, and what is guaranteed about it.
2. Name the brute-force solution and its complexity before improving on it.
3. Choose the data structure from the access pattern, not from familiarity.
4. State the target complexity and say which constraint rules the naive version out.

Follow-up

• How does this change if the input no longer fits in memory?
• What is the worst case, and how likely is it on real data?

What is the Big O complexity of your proposed solution?

Medium · Technical Fundamentals and Algorithms

Approach

1. Restate the input: its shape, its size, and what is guaranteed about it.
2. Name the brute-force solution and its complexity before improving on it.
3. Choose the data structure from the access pattern, not from familiarity.
4. State the target complexity and say which constraint rules the naive version out.

Follow-up

• How does this change if the input no longer fits in memory?
• What is the worst case, and how likely is it on real data?

Given an array of integers, return an array that contains all possible permutations of the initial values.

Medium · Technical Fundamentals and Algorithms

Approach

1. Restate the input: its shape, its size, and what is guaranteed about it.
2. Name the brute-force solution and its complexity before improving on it.
3. Choose the data structure from the access pattern, not from familiarity.
4. State the target complexity and say which constraint rules the naive version out.

Follow-up

• How does this change if the input no longer fits in memory?
• What is the worst case, and how likely is it on real data?

How would you use a HashMap to optimize a search or processing task?

Medium · Technical Fundamentals and Algorithms

Approach

1. Restate the input: its shape, its size, and what is guaranteed about it.
2. Name the brute-force solution and its complexity before improving on it.
3. Choose the data structure from the access pattern, not from familiarity.
4. State the target complexity and say which constraint rules the naive version out.

Follow-up

• How does this change if the input no longer fits in memory?
• What is the worst case, and how likely is it on real data?

Explain the difference between various data structures and when to choose one over another.

Medium · Technical Fundamentals and Algorithms

Approach

1. Restate the input: its shape, its size, and what is guaranteed about it.
2. Name the brute-force solution and its complexity before improving on it.
3. Choose the data structure from the access pattern, not from familiarity.
4. State the target complexity and say which constraint rules the naive version out.

Follow-up

• How does this change if the input no longer fits in memory?
• What is the worst case, and how likely is it on real data?

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

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

Find version gaps and relay lag with window functions

Medium · window functions · event tables · frame semantics

outbox_event holds event_id, aggregate_type, aggregate_id, aggregate_version, event_type, payload, status ('pending','published','dead'), attempts, created_at, published_at. A projection is missing rows and you must decide whether the relay skipped events or the consumer dropped them. Write three queries over the last seven days: one listing every aggregate_id whose published aggregate_version sequence has a hole, one giving per-day counts with a running total, and one returning the newest published event per aggregate. For each, say where the window function is evaluated relative to WHERE and LIMIT. PostgreSQL 16.

Approach

1. Gaps: compute lead(aggregate_version) OVER (PARTITION BY aggregate_id ORDER BY aggregate_version) in a subquery, then filter next_version <> aggregate_version + 1 in the outer query. Window functions are evaluated after WHERE, GROUP BY and HAVING and before the outer ORDER BY and LIMIT, so the predicate cannot sit in the same WHERE clause and PostgreSQL 16 has no QUALIFY.
2. Say what the seven-day filter does to the answer: it truncates every partition, so the first row per aggregate has no predecessor inside the window and a hole spanning the boundary is invisible. Widen the window, or join to resource.version as the authority for the true maximum.
3. Running total: SELECT date_trunc('day', created_at) AS d, count() AS n, sum(count()) OVER (ORDER BY date_trunc('day', created_at) ROWS UNBOUNDED PRECEDING). An aggregate inside a window call is legal because grouping runs before windowing. The grouping key is unique per row here so ROWS and RANGE agree, but write the frame anyway — over ungrouped rows with tied timestamps the default RANGE frame pulls in every peer row and the total jumps.
4. Newest per aggregate: DISTINCT ON (aggregate_id) ... ORDER BY aggregate_id, aggregate_version DESC is the cheap PostgreSQL-only form when an index matches that order; row_number() OVER (PARTITION BY aggregate_id ORDER BY aggregate_version DESC) = 1 is the portable form and needs a subquery for the same evaluation-order reason as the gap query.

Follow-up

• Relay failover redelivers events. Does a duplicate break the gap query, and how would you detect one from this table alone?
• Turn the gap check into a continuous monitor rather than a query someone runs after an incident. What does it watch?

Explain Javascript scope and the behavior of callbacks.

Medium · Web Technologies and Domain Knowledge

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 do you approach layout problems using CSS Flexbox or Grid?

Medium · Web Technologies and Domain Knowledge

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 are your preferred methods for scripting repetitive tasks?

Medium · Web Technologies and Domain Knowledge

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 interests you about the specific challenges we face at Scalable Press?

Medium · Behavioral and Cultural Fit

Approach

1. Fix the scope first: who calls this, how often, and what they do when it fails.
2. Name the read and write paths separately; they rarely have the same bottleneck.
3. Choose a partition key and say what query it makes expensive.
4. State the consistency you need, and where you are willing to be stale.

Follow-up

• What breaks first when traffic grows ten times?
• How does this behave when that dependency is down for an hour?

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 Scalable Press candidates report.

Day 1 — Map the Scalable Press loop

• Write out the reported sequence: Recruiter Screen, Technical Interviews, Technical Assessments, Onsite Interview.
• For each round, write one sentence on what it is judging, from the description above, and mark the one you are least ready for.

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

Day 2 — Work Time Complexity Analysis (Big O notation)

• Spend the session on Time Complexity Analysis (Big O notation), which Scalable Press candidates report being tested on.
• Write one worked example in Time Complexity Analysis (Big O notation) and time yourself on it.

Deliverable: One timed worked example in Time Complexity Analysis (Big O notation).

Day 3 — Work Algorithms (general)

• Spend the session on Algorithms (general), which Scalable Press candidates report being tested on.
• Write one worked example in Algorithms (general) and time yourself on it.

Deliverable: One timed worked example in Algorithms (general).

Day 4 — Work Data Structures

• Spend the session on Data Structures, which Scalable Press candidates report being tested on.
• Write one worked example in Data Structures and time yourself on it.

Deliverable: One timed worked example in Data Structures.

Day 5 — Answer out loud: Technical Fundamentals and Algorithms

• Answer aloud, timed: How do you measure the performance of an algorithm?
• Answer aloud, timed: What is the Big O complexity of your proposed solution?

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

Day 6 — Answer out loud: Web Technologies and Domain Knowledge

• Answer aloud, timed: Explain Javascript scope and the behavior of callbacks.
• Answer aloud, timed: How do you approach layout problems using CSS Flexbox or Grid?

Deliverable: Spoken answers to 2 reported Web Technologies and Domain Knowledge question(s), under time.

Day 7 — Answer out loud: Behavioral and Cultural Fit

• Answer aloud, timed: How do you handle working in a fast-paced, high-pressure environment?
• Answer aloud, timed: Describe a time you had to explain a complex technical trade-off to a teammate.

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

Behavioural preparation

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

How do you handle memory management in your language of choice?

Medium · Web Technologies and Domain Knowledge

Approach

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

Follow-up

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

How do you handle working in a fast-paced, high-pressure environment?

Medium · Behavioral and Cultural Fit

Approach

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

Follow-up

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

Describe a time you had to explain a complex technical trade-off to a teammate.

Medium · Behavioral and Cultural Fit

Approach

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

Follow-up

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

How do you approach collaborative problem-solving when you and a peer disagree on an architecture?

Medium · Behavioral and Cultural Fit

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?