Interview guides · RBC Bearings

RBC Bearings Software Engineer Interview Guide

RBC Bearings Software Engineer interview guide: reported rounds, questions and how candidates describe the process.

The 60-second brief

At RBC Bearings, a Software Engineer occupies a unique position at the intersection of high-precision manufacturing and advanced digital systems. You are not merely writing code; you are building the technological backbone that allows our complex, mission-critical bearing and precision component solutions to reach the aerospace, defense, and industrial sectors. Your work directly impacts how we optimize production lines, manage quality control data, and innovate within our design engineering processes. This role requires a blend of technical acumen and a "hands-on" mindset. Because RBC Bearings operates in highly regulated and physically demanding environments, you must be comfortable stepping away from the keyboard to engage with the manufacturing floor.

This guide is scoped to a Software Engineer candidate at RBC Bearings.

Focus areas

Machine Maintenance / Support
Production Support
Hands-on Engineering Activities

The RBC Bearings interview process

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

Initial Screening

Begin with a phone call to discuss your background and interest in the company.

What to demonstrate

Begin with a phone call to discuss your background and interest in the company
Depth in Machine Maintenance / Support

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.

On-site Visit

Visit one of the facilities, meet with the engineering team and management, and tour the manufacturing floor.

What to demonstrate

Visit one of the facilities, meet with the engineering team and management, and tour the manufacturing floor
Depth in Machine Maintenance / Support

How to prepare

Answer aloud and timed: Describe a situation where you had to work under tight deadlines.
Answer aloud and timed: What is your approach to receiving constructive criticism on your code or design work?

Project Presentation

Present your background or a specific project to the engineering team.

What to demonstrate

Present your background or a specific project to the engineering team
Depth in Machine Maintenance / Support

How to prepare

Answer aloud and timed: Why are you interested in joining RBC Bearings specifically?
Answer aloud and timed: Walk me through a project from your resume where you faced a significant technical hurdle.

Technical Deep-Dive

Engage in a technical deep-dive discussion with the engineering team.

What to demonstrate

Engage in a technical deep-dive discussion with the engineering team
Depth in Machine Maintenance / Support

How to prepare

Answer aloud and timed: How do you approach troubleshooting a system that is failing in a production environment?
Answer aloud and timed: What is your experience with design software or manufacturing execution systems?

Where candidates lose points

Show curiosity during the tour

When walking the factory floor, ask questions about the machines. Showing interest in the physical product is a strong indicator of a good cultural fit.

Be prepared for rapid-fire questions

Some of our engineering managers prefer a fast-paced interview style to see how you think under pressure. Stay calm and answer concisely.

Know your resume

Be ready to explain every project you list in detail. If you mention a specific technology, expect a follow-up question on how you used it.

Practice your "why

Have a clear, professional answer for why you want to work at RBC Bearings specifically, rather than just any engineering role.

Questions & practice

Walk me through a project from your resume where you faced a significant technical hurdle.

Medium · Technical & Problem Solving

Approach

Restate the input: its shape, its size, and what is guaranteed about it.
Name the brute-force solution and its complexity before improving on it.
Choose the data structure from the access pattern, not from familiarity.
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 do you prioritize tasks when supporting multiple stakeholders on the factory floor?

Medium · Technical & Problem Solving

Approach

Restate the input: its shape, its size, and what is guaranteed about it.
Name the brute-force solution and its complexity before improving on it.
Choose the data structure from the access pattern, not from familiarity.
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?

Describe your process for documenting code or technical processes for future maintenance.

Medium · Technical & Problem Solving

Approach

Restate the input: its shape, its size, and what is guaranteed about it.
Name the brute-force solution and its complexity before improving on it.
Choose the data structure from the access pattern, not from familiarity.
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?

Stop tag and share joins from fanning out a page

Medium · join fan-out · semi-joins · many-to-many

resource_tag is (resource_id, tag_id) with PK (resource_id, tag_id); resource_share is (resource_id, shared_with_user_id, permission). The tagged-and-shared listing inner-joins resource to both, filters tenant_id, tag_id = ANY($2) and shared_with_user_id = $3, orders by updated_at DESC and takes 50. Pages come back with fewer than 50 distinct resources and the total in the header is far too high. Explain the row multiplication, rewrite both the page query and the count query so each is correct, and name the index each one needs. PostgreSQL 16.

Approach

Do the arithmetic against the predicates that are actually there. An inner join emits one row per matching child row, and both joins are filtered: tag_id = ANY($2) admits only the requested tags, shared_with_user_id = $3 admits one user's share rows. So a resource holding three of the requested tags and shared with $3 once yields three rows, not one — the multiplier is its count of matching tags times its share rows for that single user, and that second factor is 1 unless the table admits duplicate (resource_id, shared_with_user_id) pairs. LIMIT 50 then limits rows rather than resources, and COUNT(*) counts pairs — the header is the product, not the population.
Reject DISTINCT as the fix. It deduplicates after the product has been built, so the planner must materialise and sort the fanned-out set before the LIMIT can apply, and it leaves any SUM or AVG in the same select list wrong.
Rewrite both filters as semi-joins, keeping resource as the only row source: AND EXISTS (SELECT 1 FROM resource_tag rt WHERE rt.resource_id = r.resource_id AND rt.tag_id = ANY($2)) and the same shape against resource_share. A semi-join stops at the first match per resource and preserves the driving index order, so ORDER BY updated_at DESC, resource_id DESC LIMIT 50 still stops after 50 rows.
Count with the same predicates and no join at all: SELECT count(*) FROM resource r WHERE r.tenant_id = $1 AND r.status = 'active' AND EXISTS (...) AND EXISTS (...). Nothing multiplies a resource, so the number is the population.

Follow-up

The filter changes from 'any of these tags' to 'all of these tags'. Rewrite it and state what it costs relative to the ANY form.
A resource can be shared with the same user twice under different permissions. Does your count change, and should it?

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

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?

Keep one tenant's bulk export from starving projection updates

Medium · backpressure · fair scheduling · head-of-line blocking

The worker fleet runs about 600 jobs/second out of job_run, claimed under a lease and heartbeated while running. Most handlers finish under 200 ms; exports run for minutes. One tenant enqueues 50,000 exports. Design the scheduling so that tenant's exports slow down and nothing else does: the queue split, the concurrency caps and where they are enforced, the claim query, and the backpressure signal that stops accepting new work. State the in-flight worker count each class needs at its arrival rate, and what the cap costs the tenant that hits it.

Approach

Do the concurrency arithmetic first, because it determines the pool shapes. Required in-flight work is arrival rate times service time: 600/second of 200 ms handlers needs about 120 workers, while one export per second at 180 seconds needs 180 on its own. The long tail dominates any pool it shares, so a single pool sized from the mean is consumed by exports while 50 ms projections queue behind them. That is head-of-line blocking, and adding capacity does not fix it because the ratio is what is wrong.
Split by job class rather than by priority. Priority inside one pool still lets a running export hold its worker for the next four minutes - there is no preemption for a handler already executing. Separate queues and separate worker processes give each class a floor the other cannot take.
Enforce the per-tenant cap inside the claim, not at enqueue. Claim with SELECT ... WHERE status='queued' AND run_after <= now() AND job_type=$1 ORDER BY run_after, job_run_id FOR UPDATE SKIP LOCKED LIMIT 1, restricted to tenants currently under their cap. Derive the running count from rows in status 'running' with a live lease rather than from a counter incremented at claim and decremented at completion: the derived count self-heals when a worker dies, and the counter leaks a slot every time one does.
Make the ordering fair over tenants instead of over jobs. Strict FIFO with a cap still forces the claim to scan past 50,000 rows belonging to a capped tenant before it finds anyone else's work, so cost grows with backlog depth. Pick the tenant first from a small per-tenant queue-depth summary, then claim within that tenant, which makes the scan proportional to the number of active tenants instead.

Follow-up

An export outruns its lease, so two copies run. What must the handler do to make the second copy harmless, and what does it write to guarantee that?
With a cap of 4, the tenant's 50,000 exports now take hours. What do you tell them, and does the answer change if they are the largest tenant on the platform?

Evolve the resource contract without breaking integrations you cannot upgrade

Hard · versioning · backward compatibility · deprecation

GET /v1/resources/{id} returns status from a four-value enum ('draft','active','archived','deleted'), a numeric version, and the body inline. Consumers are a browser app you deploy and roughly 300 server-side integrations, some untouched for two years, that switch exhaustively on status and parse ids as JSON numbers. You must add a 'pending_review' status, move bodies over 256 KB to a body_ref pointer, and expose per-field change history from resource_revision. Specify the compatibility policy, the wire changes, how both generations are served, and the evidence that lets you remove the old shape.

Approach

Write the policy first and date it: fields are added, never retyped or repurposed; consumers ignore unknown fields; an unknown enum value maps to a documented fallback; nothing is removed until telemetry shows no caller reads it. Then say the uncomfortable part out loud - v1 shipped without the unknown-value rule, so 300 running integrations have no fallback, and no server change can install one into code that is already deployed.
That single fact forces per-request negotiation rather than a server-side default. Keep one internal model and select a serialiser from an explicit version in the request, and default a caller that sends nothing to the oldest supported version. Defaulting to the newest is the change that breaks every integration that never asked for anything, on the day you ship.
Downgrade 'pending_review' for old callers to the nearest state they already handle, 'draft', and state the loss explicitly: those integrations cannot see review state and will treat the resource as editable. If that is unacceptable for one integration, the remedy is moving it to the new version, not a cleverer projection - there is no mapping that invents a state the client has no code for.
Make the body change additive. Old callers keep body inline; the new shape adds body_ref and a size field, and resources over the limit are served to old callers by resolving the pointer server-side or by refusing with a documented code, chosen once and published. Never repurpose body to carry the pointer: a client that renders it shows a storage key to a user, and that failure is silent, where a missing field would have been loud. While you are here, serialise BIGINT ids as strings in the new shape - a browser parsing JSON numbers gets IEEE-754 doubles, exact only to 2^53 - and treat that as its own breaking change requiring the same negotiation, not a quiet fix.

Follow-up

An old integration submits a status transition while the resource is really in 'pending_review'. What does the write path accept, and what does it reject?
Two years on you want to delete the v1 serialiser. What evidence makes that safe, and who must be contacted before it happens?

How do you approach troubleshooting a system that is failing in a production environment?

Medium · Technical & Problem Solving

Approach

Establish what changed and when, before forming any theory.
Pick a bisection that eliminates candidates whichever way it turns out.
Check the instrumentation before believing the symptom.
Separate the trigger from the cause; the deploy is rarely the bug.

Follow-up

What would you look at first, and what would it rule out?
How would you tell a cause from a coincidence here?

Suggested practice checklist

Built from the rounds and topics RBC Bearings candidates report.

Day 1 — Map the RBC Bearings loop

Write out the reported sequence: Initial Screening, On-site Visit, Project Presentation, Technical Deep-Dive.
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 Machine Maintenance / Support

Spend the session on Machine Maintenance / Support, which RBC Bearings candidates report being tested on.
Write one worked example in Machine Maintenance / Support and time yourself on it.

Deliverable: One timed worked example in Machine Maintenance / Support.

Day 3 — Work Production Support

Spend the session on Production Support, which RBC Bearings candidates report being tested on.
Write one worked example in Production Support and time yourself on it.

Deliverable: One timed worked example in Production Support.

Day 4 — Work Hands-on Engineering Activities

Spend the session on Hands-on Engineering Activities, which RBC Bearings candidates report being tested on.
Write one worked example in Hands-on Engineering Activities and time yourself on it.

Deliverable: One timed worked example in Hands-on Engineering Activities.

Day 5 — Answer out loud: Behavioral & Team Dynamics

Answer aloud, timed: Tell me about a time you had to explain a complex technical concept to a non-technical stakeholder.
Answer aloud, timed: How do you handle disagreements with team members regarding project direction?

Deliverable: Spoken answers to 2 reported Behavioral & Team Dynamics question(s), under time.

Day 6 — Answer out loud: Technical & Problem Solving

Answer aloud, timed: Walk me through a project from your resume where you faced a significant technical hurdle.
Answer aloud, timed: How do you approach troubleshooting a system that is failing in a production environment?

Deliverable: Spoken answers to 2 reported Technical & Problem Solving question(s), under time.

Day 7 — Dry run for RBC Bearings

Run one full mock under time, then write down the two questions you most want to ask your interviewers.

Deliverable: A completed timed mock and two questions to ask.