As a Software Engineer at Telus Digital, you will play a critical role in designing, building, and optimizing high-performance digital customer experience (CX) platforms and enterprise-grade software solutions. Telus Digital specializes in enabling digital transformation for some of the world's largest brands, meaning your work will directly impact millions of end-users globally. You will design scalable web applications, implement robust cloud-native architectures, and build seamless integrations that power modern user journeys. This position is highly collaborative and dynamic. Depending on your team alignment, you may find yourself working closely with global product teams, data scientists, and external enterprise clients. Engineers here do not just write code; they solve complex scalability challenges, optimize cloud infrastructure across multi-cloud environments, and ensure that applications maintain top-tier performance, security, and responsiveness under heavy loads. Whether you are building interactive frontend interfaces using modern JavaScript frameworks or architecting secure backend APIs and cloud networking pipelines, your contributions will drive the core technical capabilities of. The engineering culture values technical adaptability, structured problem-solving, and a strong commitment to delivery excellence. Telus Digital
HR Screening
reportedInitial screening to align on experience and compensation expectations.
What to demonstrate
- Initial screening to align on experience and compensation expectations
- Depth in Cloud Networking
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 Assessments
reportedSeries of assessments including online coding challenges and live technical discussions.
What to demonstrate
- Series of assessments including online coding challenges and live technical discussions
- Depth in Cloud Networking
How to prepare
- Answer aloud and timed: What are the performance implications of server-side rendering (SSR) in Next.js compared to standard client-side rendering (CSR), and how do you optimize initial page load times?
- Answer aloud and timed: Walk me through the event loop in JavaScript and explain how asynchronous operations are prioritized in the microtask queue.
System Design Review
reportedEvaluation of your system design skills through a dedicated review.
What to demonstrate
- Evaluation of your system design skills through a dedicated review
- Depth in Cloud Networking
How to prepare
- Answer aloud and timed: How do you design a secure, versioned RESTful API that minimizes payload size and handles rate limiting effectively?
- Answer aloud and timed: Explain the difference between SQL and NoSQL databases in the context of a high-throughput transaction system. When would you choose PostgreSQL over MongoDB?
Client Round
reportedParticipation in a round focused on matching technical skills and communication style with client needs.
What to demonstrate
- Participation in a round focused on matching technical skills and communication style with client needs
- Depth in Cloud Networking
How to prepare
- Answer aloud and timed: How do you handle asynchronous error propagation in Node.js and Express.js to prevent server crashes and memory leaks?
- Answer aloud and timed: Describe the process of optimizing slow-running database queries in a production environment. What indexing strategies would you implement?
PracHub editorial advice for the preparation topics above.
Going into the loop without having done this.
To maximize your chances of success during the Telus Digital interview process, keep these practical, insider tips in mind.
Going into the loop without having done this.
Clarify ambiguous requirements immediately: If a coding prompt or system design question feels open-ended, do not hesitate to ask clarifying questions. Interviewers want to see how you gather requirements and define scope before writing code.
Going into the loop without having done this.
Over-communicate during live coding: Avoid coding in silence. Walk your interviewers through your logic, explain the trade-offs of your chosen approach, and discuss how you plan to handle potential edge cases.
Going into the loop without having done this.
Be prepared for potential tech-stack overlap. Even if you applied for a specialized React role, you may face high-level questions about backend integration, Node.js, database structures, or alternative frontend frameworks like Angular.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
Walk me through the event loop in JavaScript and explain how asynchronous operations are prioritized in the mi
Walk me through the event loop in JavaScript and explain how asynchronous operations are prioritized in the microtask queue.
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
How do you handle asynchronous error propagation in Node.js and Express.js to prevent server crashes and memor
How do you handle asynchronous error propagation in Node.js and Express.js to prevent server crashes and memory leaks?
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
Merge partitioned event streams into one ordered feed with bounded lateness
The read-model service consumes 64 log partitions carrying about 4,000 events per second in total. Each partition is ordered within itself, but partitions drift by up to 30 seconds, and the activity feed must present a tenant's events in occurred_at order. Produce the merge. State its complexity, the buffer it requires in events and in bytes, what happens when one partition is idle, and what you do with an event that arrives after you have already emitted its position. Payloads average 1 KB.
Approach
- Merge with a min-heap over the 64 partition heads keyed on (occurred_at, event_id): O(log P) per event and O(n log P) overall. The tie-break on event_id is what makes the output deterministic when two partitions carry the same millisecond, which matters because the feed is paginated and a non-deterministic order reorders pages under the reader.
- Emitting the heap head is only correct once every partition has produced everything up to that timestamp, so the emit condition is a watermark: the minimum across partitions of the highest occurred_at seen, less the allowed lateness. Events are held until the watermark passes them, which is what turns individually ordered streams into a jointly ordered one.
- Size the buffer from the lateness rather than guessing: 4,000 events per second times 30 seconds is 120,000 buffered events, and at 1 KB each about 120 MB of heap. That number is the real price of the ordering guarantee and belongs in front of whoever asked for it.
- Handle the idle partition explicitly, because it fails the feed rather than corrupting it: a partition with no traffic never advances its own maximum, so the watermark freezes and output stops entirely. Either every partition emits a periodic idle marker carrying the broker's current time, or the watermark falls back to wall clock for a partition silent beyond a threshold.
Follow-up
- The lateness budget is raised to five minutes. What is the new buffer, and what besides memory changes?
- The consumer restarts. Where does it resume from, and what does the feed look like for the first 30 seconds?
Denormalise tenant onto revisions and backfill it live
resource_revision (revision_id, resource_id, version, actor_user_id, change_kind, patch, request_id, created_at) has 400M rows and no tenant column; tenant_id lives only on resource. Two reads need it: a tenant-scoped audit feed ordered by created_at DESC, and an offboarding purge. Both join back to resource today. Justify adding tenant_id to resource_revision against those two reads, name the anomaly the copy introduces and the constraint that prevents it, then give the ordered migration for a live table taking 1.2k writes/second — the lock each step takes, how the backfill is batched, and where each step stops being reversible. PostgreSQL 16.
Approach
- Justify from the access path rather than from taste. Without the column, the audit feed either scans resource_revision by created_at and discards other tenants' rows, or resolves the tenant's resource_ids first and probes with them — both proportional to the tenant's whole history rather than to one page. With (tenant_id, created_at DESC, revision_id DESC) it is a seek that stops at 50 rows, and the purge becomes a ranged delete instead of a join.
- Name the cost exactly: a second copy of a fact can disagree with the first. Make the disagreement unwritable rather than documented — add UNIQUE (resource_id, tenant_id) on resource so it can serve as a foreign-key target, then FOREIGN KEY (resource_id, tenant_id) REFERENCES resource (resource_id, tenant_id) on the revision table. A revision can then only ever carry its parent's tenant.
- Step one, expand: ALTER TABLE resource_revision ADD COLUMN tenant_id BIGINT NULL, with no default, so it is a catalogue change and no rewrite. It still needs ACCESS EXCLUSIVE for an instant, and that instant queues behind the longest open transaction on the table while every later query queues behind it — set lock_timeout to 2s and retry rather than wait.
- Step two, dual-write: deploy the writer that populates tenant_id on every new revision while reads still use the join. Reversible by redeploying the previous build, because nothing reads the column yet.
Follow-up
- The backfill is half finished and a rollback is required. What state is the table in, and what does the previous build do with a half-populated column?
- How do you verify the backfill actually finished, given rows are still being inserted while it runs?
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?
Create a card component containing a heading, subheading, summary, and image using CSS Flexbox or Grid, pullin
Create a card component containing a heading, subheading, summary, and image using CSS Flexbox or Grid, pulling data dynamically from a provided mock API.
Approach
- Say who the caller is and what they do when the call fails halfway.
- Define the identity of a request so a retry cannot double-apply it.
- Separate accepted, pending, failed and confirmed; they are different facts.
- 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?
Explain how you manage state across complex application trees in React versus Vue.js, and when you would opt f
Explain how you manage state across complex application trees in React versus Vue.js, and when you would opt for local state over global state management.
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- 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 the performance implications of server-side rendering (SSR) in Next.js compared to standard client-si
What are the performance implications of server-side rendering (SSR) in Next.js compared to standard client-side rendering (CSR), and how do you optimize initial page load times?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- 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 design a secure, versioned RESTful API that minimizes payload size and handles rate limiting effect
How do you design a secure, versioned RESTful API that minimizes payload size and handles rate limiting effectively?
Approach
- Say who the caller is and what they do when the call fails halfway.
- Define the identity of a request so a retry cannot double-apply it.
- Separate accepted, pending, failed and confirmed; they are different facts.
- 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?
Explain the difference between SQL and NoSQL databases in the context of a high-throughput transaction system.
Explain the difference between SQL and NoSQL databases in the context of a high-throughput transaction system. When would you choose PostgreSQL over MongoDB?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- 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?
Describe the process of optimizing slow-running database queries in a production environment. What indexing st
Describe the process of optimizing slow-running database queries in a production environment. What indexing strategies would you implement?
Approach
- Say who the caller is and what they do when the call fails halfway.
- Define the identity of a request so a retry cannot double-apply it.
- Separate accepted, pending, failed and confirmed; they are different facts.
- 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?
How do you configure a secure Virtual Private Cloud (VPC) in Google Cloud, and what strategies do you use to e
How do you configure a secure Virtual Private Cloud (VPC) in Google Cloud, and what strategies do you use to establish hybrid networking with an AWS environment?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- 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?
Explain the role of routing and switching protocols in enterprise environments, specifically focusing on Cisco
Explain the role of routing and switching protocols in enterprise environments, specifically focusing on Cisco-specific technologies.
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- 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?
How do you design a CI/CD pipeline that automates testing, containerizes applications using Docker, and deploy
How do you design a CI/CD pipeline that automates testing, containerizes applications using Docker, and deploys them to a Kubernetes cluster?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- 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?
What security measures do you implement to protect sensitive API endpoints from common vulnerabilities like SQ
What security measures do you implement to protect sensitive API endpoints from common vulnerabilities like SQL injection and Cross-Site Scripting (XSS)?
Approach
- Say who the caller is and what they do when the call fails halfway.
- Define the identity of a request so a retry cannot double-apply it.
- Separate accepted, pending, failed and confirmed; they are different facts.
- 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?
Design a real-time multiplayer snake game. How would you handle state synchronization between the client and t
Design a real-time multiplayer snake game. How would you handle state synchronization between the client and the server while minimizing latency?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- 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?
Walk me through the architecture of a global content delivery system. How do you ensure low latency and high a
Walk me through the architecture of a global content delivery system. How do you ensure low latency and high availability for static and dynamic assets?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- 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?
How would you design a rate-limiting service that can handle millions of requests per minute across multiple m
How would you design a rate-limiting service that can handle millions of requests per minute across multiple microservices?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- 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?
One customer endpoint stalls deliveries to every other destination
The egress service delivers about 1.5k webhooks/second across 40,000 destinations, with a per-destination concurrency cap of 4 and a 10-second connect-plus-read timeout. Throughput falls to 300/second, queue depth climbs, and p99 delivery latency for unaffected destinations goes from 200 ms to minutes, while the error rate barely moves. One tenant holds 900 destination rows whose URLs share a hostname that now answers in 9.5 seconds. Explain the mechanism with the arithmetic, then give the containment in the order you would apply it.
Approach
- Look at saturation before errors. A flat error rate with collapsing throughput says nothing is failing, things are waiting, so the first signal to pull is in-flight request count or pool wait time rather than the error counter. This is the distinction that decides the whole investigation.
- Group in-flight work by resolved host, not by destination id. The cap is keyed per destination row, so 900 rows sharing one hostname buy 3,600 concurrent slots against a single host, each held for 9.5 seconds. The bulkhead was never a bulkhead for that host, and grouping by the wrong dimension is why the dashboard looked healthy.
- Do the arithmetic in both directions. Required concurrency is arrival rate times latency, so 1.5k/second at 200 ms needs about 300 in flight, which is entirely consumed by 3,600 slow slots; conversely whatever concurrency is left sustains rate equals concurrency divided by 9.5 seconds, which is the 300/second you are seeing. Matching both numbers is what promotes this from a plausible story to the mechanism.
- Explain why the circuit breaker never helped. It opens on consecutive failures, and a 9.5-second response inside a 10-second timeout is a success. Slow is not failing, so an error-rate breaker cannot see this; you need a slow-call ratio, a deadline propagated from the caller's remaining budget, or a concurrency limiter.
Follow-up
- The host recovers to 80 ms. How long does the queue take to drain, and what does the drain do to the recovered host?
- Where should the 10-second timeout number actually come from?
Built from the rounds and topics Telus Digital candidates report.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the Telus Digital loop
- Write out the reported sequence: HR Screening, Technical Assessments, System Design Review, Client Round.
- 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.
02Work Cloud Networking
- Spend the session on Cloud Networking, which Telus Digital candidates report being tested on.
- Write one worked example in Cloud Networking and time yourself on it.
Deliverable: One timed worked example in Cloud Networking.
03Work DSA (Data Structures & Algorithms)
- Spend the session on DSA (Data Structures & Algorithms), which Telus Digital candidates report being tested on.
- Write one worked example in DSA (Data Structures & Algorithms) and time yourself on it.
Deliverable: One timed worked example in DSA (Data Structures & Algorithms).
04Work Virtual Private Cloud (VPC)
- Spend the session on Virtual Private Cloud (VPC), which Telus Digital candidates report being tested on.
- Write one worked example in Virtual Private Cloud (VPC) and time yourself on it.
Deliverable: One timed worked example in Virtual Private Cloud (VPC).
05Answer out loud: Frontend & UI Engineering
- Answer aloud, timed: Create a card component containing a heading, subheading, summary, and image using CSS Flexbox or Grid, pulling data dynamically from a provided mock API.
- Answer aloud, timed: Explain how you manage state across complex application trees in React versus Vue.js, and when you would opt for local state over global state management.
Deliverable: Spoken answers to 2 reported Frontend & UI Engineering question(s), under time.
06Answer out loud: Backend & API Design
- Answer aloud, timed: How do you design a secure, versioned RESTful API that minimizes payload size and handles rate limiting effectively?
- Answer aloud, timed: Explain the difference between SQL and NoSQL databases in the context of a high-throughput transaction system. When would you choose PostgreSQL over MongoDB?
Deliverable: Spoken answers to 2 reported Backend & API Design question(s), under time.
07Answer out loud: Cloud & Infrastructure Engineering
- Answer aloud, timed: How do you configure a secure Virtual Private Cloud (VPC) in Google Cloud, and what strategies do you use to establish hybrid networking with an AWS environment?
- Answer aloud, timed: Explain the role of routing and switching protocols in enterprise environments, specifically focusing on Cisco-specific technologies.
Deliverable: Spoken answers to 2 reported Cloud & Infrastructure Engineering question(s), under time.
Expand any day for tasks and deliverables. Your progress is saved on this device.
Behavioural rounds judge the decision you made and what it cost.
Narrate an outage you owned from page to postmortem
Pick an incident you personally drove, ideally one where writes were affected rather than reads. In six to eight minutes: state the symptom as it first appeared on a dashboard, the blast radius you established before you knew the cause, the mitigation you applied and when, the mechanism you eventually proved, and the follow-up that would prevent a repeat. Bring numbers: error rate, tenants affected, minutes to mitigate, minutes to resolve. If you cannot name what you measured, choose a different incident.
Approach
- Open on the signal rather than the cause: which metric at which percentile moved, on which service, at what time, so the listener follows the same evidence you had rather than a conclusion you already reached.
- Separate mitigation from diagnosis out loud. State what you did to stop the bleeding (flag off, shed traffic, drain a lease, roll back a deploy) and say plainly that you did it before the mechanism was known, because those are two jobs with different deadlines.
- Establish blast radius in countable terms: how many tenants, how many writes, and crucially whether the effect was loss or only delay. An append-only revision table or a pending outbox row means the change survived and the projection was merely behind, which is a repair rather than a data-loss incident.
- Prove the mechanism instead of asserting it. Name the trace span that grew, the plan that flipped to a sequential scan, the lease that expired, plus one alternative you ruled out and the signal that stayed flat while you ruled it out.
Follow-up
- What would you do differently in the first five minutes, given the same dashboard and no more information?
- Which follow-up action did you deliberately not take, and why was dropping it the right call?
Estimate work you have never done and defend the range
You are asked to estimate a change you have never attempted: add a column to a 100-million-row table, populate it, move reads across, and drop the old shape. Give a range with the assumptions that generate it, including batch size, the signal your backfill throttles on, and wall-clock hours, and name the three unknowns that would move the number most. Then describe a real estimate you gave under comparable ignorance: how you expressed its uncertainty, what you committed to, and how wrong you turned out to be.
Approach
- Decompose into independently deployable steps before estimating anything: add the column nullable, write both shapes, backfill in batches, verify, move reads, stop writing the old shape, drop it. That is four deploys spread over days, and the calendar estimate is dominated by them rather than by the loop's runtime.
- Do the arithmetic aloud for the part that has arithmetic in it: batch size times number of batches times per-batch duration, at a write rate the primary can absorb alongside roughly 1.2k writes per second of production traffic. The loop is throttled by replication lag and lock waits, not by how fast it can issue statements.
- Price the schema step by its lock rather than its statement duration. In PostgreSQL an ALTER TABLE taking ACCESS EXCLUSIVE waits for every open transaction on that table while later queries queue behind it, so a millisecond change issued during a thirty-second analytics query stalls that table for thirty seconds. Adding a nullable column with a non-volatile default avoids a rewrite from version 11; a new index wants CREATE INDEX CONCURRENTLY, which cannot run inside a transaction block and leaves an invalid index behind if it fails.
- Express the answer as a range whose endpoints each trace to a stated assumption, then name the cheapest experiment that collapses it, which is almost always running one real batch against the real table and multiplying.
Follow-up
- How do you verify the backfill genuinely finished, given rows written by production traffic while it ran?
- Where does the backfill resume from after a worker is killed mid-batch, and what makes that resume point trustworthy?
Unblock an engineer without taking the keyboard
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
- 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.
- 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.
- 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.
- 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?
- 01
Pick an incident you personally drove, ideally one where writes were affected rather than reads. In six to eight minutes: state the symptom as it first appeared on a dashboard, the blast radius you established before you knew the cause, the mitigation you applied and when, the mechanism you eventually proved, and the follow-up that would prevent a repeat. Bring numbers: error rate, tenants affected, minutes to mitigate, minutes to resolve. If you cannot name what you measured, choose a different incident.
- 02
You are asked to estimate a change you have never attempted: add a column to a 100-million-row table, populate it, move reads across, and drop the old shape. Give a range with the assumptions that generate it, including batch size, the signal your backfill throttles on, and wall-clock hours, and name the three unknowns that would move the number most. Then describe a real estimate you gave under comparable ignorance: how you expressed its uncertainty, what you committed to, and how wrong you turned out to be.
- 03
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.
What is the typical timeline for the Telus Digital hiring process?
The entire process generally takes between 3 to 5 weeks from the initial recruiter screen to the final offer. However, timelines can occasionally vary depending on the specific client alignment and the availability of technical interviewers.
Telus Digital Software Engineer candidate reports ↗How technical is the managerial round?
The managerial round focuses primarily on team fit, communication, and your approach to collaboration. While it is less about writing code, you should still be prepared to discuss your past projects, architectural decisions, and how you handle technical disagreements or shifting project requirements.
Telus Digital Software Engineer candidate reports ↗Do I need experience in both AWS and GCP?
While deep expertise in both is not strictly required, a strong conceptual understanding of cloud networking and deployment principles is highly valued. Most roles will allow you to specialize in one platform while collaborating on multi-cloud architectures.
Telus Digital Software Engineer candidate reports ↗What is the hybrid work policy at Telus Digital?
Telus Digital supports a flexible hybrid working model for most engineering roles, allowing developers to balance remote work with collaborative in-office sessions depending on local office guidelines and client requirements.
Telus Digital Software Engineer candidate reports ↗How hard is the Telus Digital interview?
Candidates most commonly rate Telus Digital interviews as medium, based on 507 reported interviews. About 63% of candidates who interview go on to receive an offer.
Telus Digital Software Engineer candidate reports ↗What topics does Telus Digital test in interviews?
Telus Digital interviews most often cover Python, SQL, Cross-functional Collaboration, Behavioral Interviewing, and Cloud Networking. The exact emphasis depends on the specific role you apply for.
Telus Digital Software Engineer candidate reports ↗Sources & methodology 3 sources ↗
Official role evidence, timestamped platform data and clearly labeled preparation advice.
- 01Telus Digital Software Engineer candidate reports ↗
Company-reported rounds, questions and FAQ.
candidate · Accessed 2026-09-22 - 02PracHub Software Engineer practice ↗
PracHub practice material, not company-reported.
platform · Accessed 2026-09-22 - 03PracHub preparation framework ↗
PracHub preparation guidance.
platform · Accessed 2026-09-22
Explore related engineering environments and compare the preparation focus.
Verkada Software Engineer Interview Guide
What Verkada asks Software Engineer candidates, from reported rounds and questions.
The Marlin Alliance Software Engineer Interview Guide
What The Marlin Alliance asks Software Engineer candidates, from reported rounds and questions.
Theinclab Software Engineer Interview Guide
What Theinclab asks Software Engineer candidates, from reported rounds and questions.
Teraswitch Software Engineer Interview Guide
What Teraswitch asks Software Engineer candidates, from reported rounds and questions.