CoreWeave AI Infrastructure Engineer interview questions

Trace a grid into blocks and warps, then distinguish resident work from ready work. Derive an occupancy limit without treating it as a speed target.

Separate H200 bandwidth and capacity gains from measured speedup, then test realistic memory headroom and cost per useful completed workload.

Separate Blackwell chip gains from the 72-GPU domain, follow a token to its expert owners, and test placement instead of dividing model bytes by 72.

See the GPU-instance and compute-instance boundaries, budget a small slice, and distinguish memory capacity controls from bandwidth isolation.

Trace a changed BF16 bit, distinguish corrected and uncorrectable errors, and calculate recovery cost without assuming every device has the same ECC overhead.

Compare the cost of serving the same workload at the same latency and quality. A memory-traffic estimate explains what each GPU might improve; measured throughput and your actual rental price determine the purchase.

Compare the same benchmark on a healthy node, then follow the evidence through NCCL transport choices, device topology and fabric health. Half the measured bandwidth is a symptom, not a unique diagnosis.

Specify a cluster from workload and facility constraints, then derive node counts, network ports, storage bursts and acceptance tests.

Compare GPU memory, decode traffic and measured useful throughput. Work out a capacity ceiling without mistaking it for a performance forecast.

Compare rack-level power, cooling, structural and connectivity requirements with the offered site, then evaluate quoted deployment alternatives.

Diagnose failed 800G links using endpoint compatibility, lane modes, inventory and controlled swaps. Learn why speed labels and failure patterns do not prove a cause.

Build a cluster power budget with clear equipment boundaries, facility overhead and failover requirements. Distinguish energy use from reserved electrical capacity.

Derive cooling flow for a 4.8 MW hall, separate liquid and air loads, and test CDU capacity and redundancy at the actual design conditions.

Localize a slow fabric rail with matched tests, path comparisons and counter deltas. Separate an independent-bandwidth sum from collective completion time.

Bring up the supported hardware and software stack one dependency at a time, then prove correctness and recovery at increasing scale.

Define acceptance with component and system tests, absolute targets, peer comparisons and documented retests. Interpret burn-in exposure without treating it as a reliability guarantee.

Investigate rack power events at the correct electrical boundary and time scale. Test load reductions without assuming GPU caps control every watt or transient.

Count one complete rail, then distinguish logical links from cages, optical modules and cable assemblies. Derive power from the same physical inventory.

Diagnose a multi-node regression by comparing host and GPU transfer paths, active registration mechanisms and the tested software stack.

Build a storage budget that includes retained checkpoints, the next save, overlapping datasets and failure protection. Then check whether the same tier can meet write and restore deadlines.

Design a management path that survives specified production failures. Count all endpoint classes, restrict device authority and test the complete recovery route.

Compare cooling methods from the supported hardware and heat path. Calculate airflow or liquid flow, then verify capacity, residual air load and failure response.

Build a deployment schedule from dependencies and committed lead times. Calculate float and price the delay only when an action moves usable capacity earlier.

Estimate replacement demand over replenishment time, then size for shortage risk and failure correlation. Distinguish shelf parts from runnable spare nodes.

Investigate widespread acceptance failures using matched controls, valid thresholds and cohort denominators. Preserve hardware and shared causes as testable hypotheses.

Separate compute, storage and management responsibilities, then decide which need independent physical paths and count their endpoints correctly.

Compare 64 or 72 useful GPUs, identify the communication that could improve, and test whether a larger NVLink domain justifies the operational requirements.

Compare ownership, colocation and rental using the same useful work, full annual costs and realistic demand. Work a break-even from explicit assumptions.

Budget the full megawatt, fit whole servers, and compare useful training throughput under measured power limits. A worked cap example shows when more GPUs help.

Fabric Manager helps make an NVSwitch system ready. Learn the platform-specific roles, failure symptoms and checks that prove the communication path works.

Choose a supported tenant boundary, secure the surrounding services, and verify cleanup before reassignment. Calculate fragmentation from actual requests.

Map stable endpoints to rails, choose supported cables from measured routes, and verify topology before interpreting collective performance.

Reproduce the baseline, compare equivalent work, and trace the missing time. Acceptance, production and the original plan may differ in more than one way.

Protect running work, validate a supported upgrade bundle, and expand through measured cohorts with a tested recovery path.

Plan a GPU-generation migration around usable workload capacity, site readiness, compatibility and a tested rollback path.

Test the vendor claim on your workload, including quality, latency, scaling and operating costs. A lower peak or lower price alone does not settle it.

Gate admission with fresh, platform-aware evidence. Use absolute and peer baselines, budget test overhead and keep automated cordons under control.

Keep the full failure history and investigate what changed. One passing retry is evidence, but it is not a repair or an acceptance policy.

Survey real facility headroom, phase work around shared dependencies, and compare retrofit with relocation using useful capacity and total transition cost.

Define who owns each facility and hardware action, model restoration time, and verify power, cooling, telemetry and growth commitments before deployment.

Confirm the event definition and exposure, compare cohort rates, then test whether the cause follows a module, location or optical path.

Collect stable device identities, versions and freshness, then compare them with approved configurations and retain the history for investigations.

Compare complete fabric proposals on workload performance, support and total cost. Translate any measured regression into application impact before pricing the discount.

Compare the old fleet's useful value with operating costs and resale, verify its health, and complete data handling before reassignment or transfer.

Diagnose a rack outage through independent evidence, preserve safety interlocks, and restore capacity only after its failed paths pass acceptance checks.

Read a watchdog timeout without blaming the reporting rank. Compare group-scoped traces, separate missing evidence from mismatched calls, and distinguish CPU submission from GPU completion.

Work from each GPU's cache budget, reserve room for generated tokens, then check latency separately. A limiting-rank example shows why fitting today's prompts is not enough to admit tomorrow's work.

Derive a deployment candidate from the official tensor index, then account for latent-cache replication and the product workload. A worked example shows why enough aggregate HBM can still leave every GPU out of memory.

Use the actual tensor index to size Kimi K3, then separate a published hardware starting point from production capacity. Account for mixed precision, hybrid recurrent state, parser behavior, and the workload behind a throughput claim.

The nodes joined the cluster, but the first request hangs. Trace how far it got, check worker assignments, and reproduce the blocked operation on the same communication path.

The output forecast is a starting point. Match the prompt and state workload, derive replica counts from an SLO-tested rate, check simultaneous loss scenarios and keep the cost denominator consistent with the forecast.

An apparent outlier can reflect workload mix, queueing, runtime state or a degraded execution path. Normalize the comparison, run a matched replay and use critical-path arithmetic to test possible causes.

Design a shared catalogue with explicit service tiers, reproducible deployments and bounded cold starts. Residency depends on burst behavior and resource reuse; placement depends on GPU groups and interference as well as memory.

Walk a single-GPU vLLM Deployment from pod scheduling to the first token, then show the three settings that turn a working manifest into restart loops and stuck rollouts.

Build a power budget from complete servers to the facility meter, then check rack limits and distinguish a design maximum from an annual electricity bill.

Compare ownership with the actual rental contract, using explicit cash flows, resale assumptions and the hours that can really be avoided.

Count weight and cache traffic on a specified B200 configuration, check finite capacity, and separate aggregate throughput from per-user pace. Worked bounds guide a benchmark rather than replace it.

Use bandwidth per dollar as a first comparison, then check feasible memory, supported execution and complete service cost before ranking accelerators.

Follow corresponding GPU positions through a rail, including the leaf and spine links needed when one rail outgrows a switch.

A bandwidth regression narrows the search only after the experiment is defined. Work through rank-count normalization, controlled path tests and the difference between collective time and training progress.

Separate NCCL logging, device selection and execution overrides from PyTorch failure handling. Work through a faster collective that makes the job slower, and learn which timeout actually fired.

Derive a complete rail topology and distinguish physical links, switch ports and transceivers. Size storage and management from their own requirements.

Trace a link flap through transport and job recovery. Calculate detection, restart and replay costs, and learn what continuous counters and timed tests can actually establish.

Two tenants can fit the average storage budget and still miss both checkpoint deadlines. Work through reservations, borrowing and bounded admission while protecting training reads, then test the design under failure.

Investigate a firmware-correlated regression with matched metrics, mapped paths and a controlled canary. Separate a configuration hypothesis from evidence that confirms it.

Follow a four-GPU request from advertised capacity to concrete devices, and see why free GPUs across nodes cannot satisfy one pod.

Compare the resource promises of MIG, time-slicing and MPS, then test peak memory and simultaneous demand before packing workloads.

Choose the control plane from job admission, placement, recovery and service needs, with a concrete partial-allocation failure.

See how partial allocation can strand two training jobs. Separate group admission, real placement, readiness and recovery instead of assuming atomic pod startup.

Design fractional GPU admission around explicit shapes and enforceable guarantees, then reconcile reservations with the runtime.

Use actual rank placement and measured job duration to decide whether waiting for locality beats starting immediately.

Diagnose GPU pod failures by scheduling, container startup and execution boundaries, without treating Allocatable as a health certificate.

Separate discovery labels, GPU resource advertisement and validation, and understand the operator as a reconciler with configurable components.

Size usable inference headroom from the complete readiness delay and demand ramp, then decide which training capacity can safely be borrowed.

Compare the cost of committed capacity with the demand each additional GPU would actually serve. Keep billing discounts separate from capacity guarantees, and account for bursts without counting the same work twice.

Count feasible placements for the waiting job, including its per-node and topology requirements. Then compare waiting, reservations and checkpoint/restart consolidation using their actual disruption costs.

Use a short admission check for recent changes and a deeper acceptance suite for new or repaired nodes. Set thresholds from matched healthy baselines, and make quarantine and return-to-service decisions explicit.

Keep the training state and replace the failed capacity. Trace fault detection, safe checkpoint selection, worker shutdown and restart; size spare capacity from observed failures and repair times.

A fabric address, an RDMA device and a working GPU-memory registration path are separate requirements. Verify each inside the pod, then test the actual GPU-to-NIC placement and collective behavior.

Treat the upgrade as a tested change to a compatibility set. Drain safely, canary representative workloads, size waves from usable spare capacity and rehearse restoration of the previous working configuration.

Trace the job from quota reservation through admission to physical placement. Count eligible node shapes, not just free GPUs, and use controller and scheduler evidence to choose the least disruptive fix.

Use the Llama 3 interruption record without turning job interruptions into device lifetime, predictable failures or a universal spare percentage.

Interpret XID codes with device and software context, separating immediate recovery from evidence-based root-cause investigation.

Use DCGM fields with their actual semantics, combine device health with workload progress, and calibrate alerts on correlated fleet data.

Investigate rising corrected-memory errors without promising a failure prediction, and follow recovery flags and vendor repair criteria.

Handle an inaccessible GPU with bounded recovery and preserved evidence, without treating a reboot or repeat count as proof of root cause.

Build an acceptance suite around the node’s intended workload and supported hardware limits. Combine configuration, correctness, communication and sustained-load evidence, then record a baseline and an explicit return-to-service decision.

Correlate clock-event reasons, temperature, configured limits and workload timing. Use the scope of the slowdown to choose the next investigation, and distinguish intentional power limits from unexpected thermal constraints.

Page when material impact or risk needs timely human action. Verify that automation actually recovered the workload, group related events, and use measured responder load to improve the policy.

Give every health-state transition a reason, owner and completion condition. Calibrate intervention against missed-fault risk and disruption cost, and prevent a bad signal source from removing the whole fleet.

Page when timely human action matters. Use budget burn, careful grouping, bounded maintenance rules, and regular testing to keep those pages useful.

Loss of cooling can outpace human response. Use a simple heat calculation to explain why protection must be automatic, then distinguish that illustration from the installed system’s validated behavior.

Separate removing a suspect GPU from production from proving it qualifies for replacement. Use vendor recovery requirements, device history, targeted tests, and the cost of recurrence.

Determine what the replacement count measures, compare equivalent device exposure and investigate differences by cohort, location, age, software and policy. Job-interruption statistics cannot supply a hardware replacement baseline.

Follow GPU ownership from reservation through verified delivery and cleanup, with stale-operation fencing, recovery and auditable metering.

The union is a sort and a scan. The intersection is the same sweep with a counter, and it is the one that goes wrong, because a single GPU reporting overlapping intervals will be counted twice and produce an answer that looks plausible. Both implementations, the trap, and the tests that catch it.

Compare three GPU placement heuristics with executable traces. Show how admission and free-space shape change, then add workload and topology constraints.

Write a bounded Go downloader that propagates cancellation, joins every worker and publishes files under explicit unique names.

Reconstruct GPU-hour intervals, clip them to a period and preserve provisional usage and conflicting-event evidence.

Design job creation, cancellation and listing around retries, durable ownership and an explicit pagination contract.

Build a complete segmented metrics-store reference with duplicate-safe range queries, visible retention and tested compaction.

Tell an incident through the decisions you made, the evidence available at the time and the cost of recovery. Keep your role clear and distinguish mitigation from finding the root cause.

Connect an infrastructure problem you want to solve with work you have actually done. Explain what prompted the move now, what transfers from your background and what you still need to learn.

Compare net time saved, maintenance and failure risk before automating. Work a payback example and explain why concurrency limits alone do not bound repeated damage.

Explain how a plausible diagnosis became too certain, what disproved it and what changed in your investigation. Separate observed symptoms from causal evidence.

Build a learning habit around questions, source evidence and practical tests. Explain a real example without claiming work you did not perform.

Show a cost reduction with comparable service evidence, realized savings and a feasible recovery plan. Distinguish a quiet trial from proof of unchanged reliability.

Use an evidence-based timeline, specific contributing conditions and verified follow-up to make a postmortem useful.

Evaluate a proposed 2,000-GPU purchase using compatible capacity, dated demand and complete alternatives. Make any gap left by reclaim visible.

Move a vendor case forward with controlled comparisons, a faithful reproduction and a safe mitigation. Escalate by impact while evidence improves.

Coordinate simultaneous incidents with the people available. Contain urgent harm, assign next actions and revisit priorities as evidence changes.

Explain a career move using the actual role, team and your priorities. Test assumptions about ownership, hardware access and support.

Offer a first-90-days plan with useful early work and clear decision points. Let the team’s evidence and constraints determine the deliverable.

Explain an isolation finding through the intended boundary, authorized evidence, designated reporting process and checks for both denied and permitted access.

Follow one request from API admission to streamed output, then zoom into the token-generation loop. See where the cache lives, who schedules work, and how workload measurements turn the drawing into a capacity plan.

Trace GPU credits through reservation, allocation, metering and settlement, with crash-safe ownership and a separate fairness policy.

Choose between supported InfiniBand and RoCE designs using workload tests, congestion behavior and a complete cost model.

Track request admission through a concrete page-reservation example, then connect scheduling, growth and stream cleanup to measured service limits.

Derive a 10,240-GPU layout from model work, then account for collective traffic, durable checkpoints, power and replacements. A nested diagram connects tensor, pipeline and data parallel groups to the fleet.

Separate quota, borrowing, reclaim latency and fairness, with a demand-conserving example of when pooling improves utilization.

DRA gives the scheduler device claims and attributes to work with. Compare that with extended-resource counts, then check the deployed driver and controller support before promising sharing, partitioning or gang placement.

Use a flexible 45-minute plan to connect requirements, a request path, capacity arithmetic, selected deep dives and a clear closing decision.