Generative AI Engineer interview questions

I would expose one policy and job contract but schedule each modality in a separate execution class.

• The gateway resolves tenant, modality, model manifest, safety policy, deadline, and cost ceiling before dispatching to image, video, audio, or text queues.
• Interactive text, image previews, and audio get deadline-aware admission, while video uses durable asynchronous jobs with progress events and idempotent output publication.
• A capability registry prevents false portability by declaring resolution, duration, conditioning, streaming, hardware, and artifact compatibility per model.
• Load tests at 39,000 requests per minute verify 30% headroom, modality-specific p99, quality gates, and graceful rejection when a GPU pool saturates.

I would size from measured GPU-seconds per accepted asset and keep preview and final renders in separate queues.

• Two million per day averages 23.1 assets per second; a 5 times peak and 25% headroom require capacity for about 145 accepted assets per second.
• If an optimized eight-step pipeline sustains 2.4 images per GPU-second, the peak needs about 61 GPUs before redundancy, safety retries, and maintenance reserve.
• Continuous dynamic batching groups compatible model, resolution, scheduler, adapter, and conditioning requests while a four-second deadline caps queue wait.
• Success excludes safety rejections and client cancellations, and the 99.9% SLO counts only admitted jobs that must publish exactly one immutable asset.

The SLO is feasible only with two-GPU gang-scheduled workers and almost no queue delay.

• Two GPUs at 80% efficiency give a wall time of 18 divided by 1.6, or 11.25 minutes, leaving only 45 seconds for queueing, safety, muxing, and publication.
• Scaling loss makes each job occupy 22.5 allocated GPU-minutes; 20,000 jobs need 7,500 allocated GPU-hours daily, averaging 312.5 GPUs.
• At 70% effective utilization plus 20% reserve, I would provision about 268 two-GPU slots, or 536 GPUs, then validate the arrival distribution rather than rely on the daily average.
• Admission reserves both GPUs atomically, tracks stranded single GPUs as fragmentation, and rejects or degrades work when a slot cannot start within the 45-second non-generation budget.

I would size from measured batched stream capacity, not convert real-time factor directly into physical GPUs.

• Inference needs 200 divided by 8, or 25 L40S GPUs; 30% headroom rounds that to 33, and retaining it after one four-GPU host failure requires 40 deployed GPUs, or ten complete hosts.
• The measured 175 ms plus the 60 ms buffer uses 235 ms of the 300 ms budget, leaving 65 ms for network and gateway delay; the buffer remains below the 80 ms jitter objective.
• Session-affine workers bind tenant, model, speaker embedding, consent, locale, and codec, while batch slots and caches carry the same isolation key.
• A 260-stream test plus host removal verifies first-audio p99, underruns, streams per GPU, cancellation, and failover rather than assuming linear scaling.

I would make the canonical product bundle an immutable control plane and generate only the scene, lighting, camera motion, and copy around it.

• The SKU registry versions the approved mesh, dimensions, UVs, PBR maps, logo decals and masks, calibrated colors, and allowed camera ranges under one digest; every job pins that digest and generation cannot rewrite product surfaces.
• A geometry-conditioned pipeline renders depth, normals, segmentation, shadow, and product beauty passes from the mesh, generates backgrounds and motion against those controls, then composites or rerenders the locked product pass for each image frame or video shot.
• Automated gates compare silhouettes and landmarks across eight views at IoU at least 0.995, require logo template similarity at least 0.98 and color-managed albedo Delta E 2000 at most 2, and verify PBR digests plus reference highlight tests; failures enter a human exception queue that cannot alter the SKU bundle.
• Capacity tests at a 3 times hourly peak must sustain 10,000 accepted ads per day with image p95 below 12 seconds, video p95 below 120 seconds, cost per accepted image at most $0.15, cost per accepted video at most $1.20, at least 98% first-pass acceptance, and zero SKU violations in a 5,000-asset release audit.

I would make data legality, token throughput, and recoverability first-class parts of one immutable training manifest.

• A pilot measures examples per GPU-second at target resolution; the full run needs at least 386 examples per second to see 1 billion pairs once within 30 days, before evaluation and downtime.
• Versioned shards store license grant, source, checksum, caption transform, dedup cluster, opt-out status, and preprocessing code hash, with invalid records removed before sampling.
• FSDP or ZeRO shards optimizer state, mixed precision and activation checkpointing fit the model, and topology-aware data loading keeps 512 GPUs fed.
• Checkpoints every 20 minutes cap lost work, while fixed prompts, FID-like distribution metrics, human preference, safety, and memorization probes gate continuation.

I would define recovery by the age and restorability of the last successful checkpoint, not by a checkpoint timer.

• Capacity is modeled in encoded frames by duration and resolution; 27.6 clips per second is only a sanity check because clip costs differ.
• A checkpoint starts every 10 minutes, has a three-minute p99 write budget, and becomes visible only after checksums, shard completeness, and an atomic manifest commit succeed.
• The manifest captures model, optimizer, scheduler, loss scaler, dataloader and sampler position, ordered shard cursor, and every RNG state needed to resume the exact sequence.
• Failure drills kill workers and the coordinator, restore on fresh nodes, compare subsequent batches and losses, and alert when last-successful-checkpoint age approaches 15 minutes.

I would split by rights holder and artist before feature extraction, then train from a versioned rights-aware sample manifest.

• Each segment carries recording and composition grants, territory, expiry, artist, ISRC-like identifier, checksum, and allowed training purpose; expired grants stop future sampling.
• Loudness normalization, resampling, source separation, codec tokens, and text conditioning are pinned transforms, with artist and track groups kept out of validation leakage.
• Throughput is budgeted in audio-hours per GPU-hour, not tracks, and duration buckets prevent ten-minute songs from dominating step time.
• Release gates combine listener preference, intelligibility, musical structure, safety, and nearest-neighbor memorization tests against the licensed catalog.

I would separate adapter training, compatibility validation, registry publication, and serving admission under one tenant-scoped manifest.

• Training queues are weighted by plan and GPU-seconds, with quotas preventing one tenant from occupying all 50 slots and predicted cost checked before admission.
• A default LoRA recipe sweeps only rank 16 and 32 on a held-out identity and style set; early stopping ends runs that cannot beat the base within the $12 ceiling.
• Every adapter records base hash, VAE, text encoder, target modules, rank, precision, dataset consent, recipe, and eval result before atomic publication.
• At 95% two-hour completion, capacity tests include 65 concurrent jobs, failed nodes, retries, and artifact upload rather than timing only the training loop.

I would authorize and load adapters through a tenant-scoped broker, then publish them atomically into bounded per-replica caches.

• The cache key includes tenant, adapter version, base hash, tokenizer, VAE, and precision; a digest mismatch or wrong tenant is a hard rejection.
• Requests batch across adapters only if the engine applies separate weights correctly, while KV, latent, CUDA graph, and output caches include the same isolation key.
• Concurrent misses coalesce into one verified download, hot adapters are pinned by measured demand, and cold-load time remains visible in the five-second p99.
• Cross-tenant fuzz tests, memory-scrub tests, signed artifact checks, and audit logs prove control behavior without claiming GPU memory is magically confidential.

I would make a release manifest bind the model artifact to every evaluation, dependency, policy, and product approval required to run it.

• The registry stores immutable hashes for weights, architecture, tokenizer or codec, VAE, preprocessing, adapters, runtime image, prompts, safety policy, and license status.
• Evaluation records point to exact dataset, rubric, judge, human panel, seeds, hardware, and per-slice results rather than a single pass badge.
• A compatibility graph declares which surfaces and runtimes may consume each artifact, and promotion uses signed stage transitions rather than mutable labels.
• Rollback reactivates the previous complete manifest and routing weights; quarterly drills prove restoration within 10 minutes for all 18 surfaces.

I would treat each evaluation as a content-addressed experiment whose prompt, conditioning, generation, and scoring inputs cannot drift.

• The manifest pins prompt text, negative prompt, seeds, aspect ratio, duration, input assets, masks, scheduler, guidance, steps, model graph, and runtime container.
• The scheduler stratifies 4,000 prompts by safety, typography, anatomy, composition, motion, language, and product use, then allocates equal paired seeds across candidates.
• Cached generations are reused only under an exact manifest hash; metric code and embedding models are versioned outputs, not invisible platform dependencies.
• The six-hour gate reports paired deltas and confidence intervals by slice, failing incomplete cells rather than comparing models on different prompt subsets.

I would preregister the independent unit as a prompt pair and power the primary forced-choice estimand before opening the panel.

• A normal approximation needs about 6,600 independent pairs for 90% power at a two-point effect; a pilot estimates reviewer and prompt clustering, and n is multiplied by that design effect.
• Three blinded judgments per pair at 45 seconds use about 248 hours before design-effect expansion, leaving room within 600 hours for quality checks and slice oversampling.
• Reviewer assignment crosses models and prompt strata, gold items detect inattention, and a mixed model avoids treating repeated reviewers as independent.
• The primary test uses alpha 0.05; four critical slices use Holm correction and pilot-powered sample sizes, with no aggregate win overriding an underpowered or failing slice.

I would make the 8 to 12-second severe-flicker delta the primary paired endpoint, separate from frame aesthetics.

• With one-sided alpha 0.05, 4% discordance, and a one-point margin, roughly 3,500 pairs provide 90% power; I would allocate 4,000 clips to that duration and 6,000 elsewhere.
• Motion, cuts, faces, text, and occlusion are prespecified sub-slices; 1,000 relevant pairs per critical sub-slice gives an approximate two-point MDE, stated honestly.
• Deterministic decode aligns timestamps, while optical flow, tracking survival, and embedding drift diagnose failures labeled for severity by blinded reviewers.
• A one-sided paired bound must stay within one point, Holm-adjusted critical slices must pass, and the 6% adherence gain cannot compensate for temporal failure.

I would turn the time budget into judgments, then let a paired-score pilot determine which language claims are supportable.

• At one minute per judgment, 1,200 hours provide 72,000 judgments; three listeners per pair yield at most 24,000 pairs, or 600 per language equally.
• The pilot estimates paired-score variance and listener correlation; n equals ((z alpha plus z power) times paired SD divided by one point) squared, inflated for repeated listeners.
• If 600 pairs cannot support the bound after Holm correction, I would narrow a preregistered critical-language set or fund more review, not declare all 40 non-inferior.
• Hidden references and degraded anchors qualify listeners, while separate naturalness, intelligibility, prosody, artifact, and speaker-fidelity endpoints expose codec damage.

I would build modality-specific cascades, but promotion depends on exact-binomial bounds from independently sampled positive and negative banks.

• At design recall 99.9% versus the 99.5% floor, a normal power calculation needs about 1,550 severe positives per critical slice; exact simulation sets final n and allowed misses.
• At design false-positive rate 0.7% versus the 1% ceiling, about 8,200 benign negatives per slice provide 90% power, finalized with an exact one-sided upper bound.
• Image, video, transcript, acoustic, and text detectors feed a calibrated combiner, while uncertain high-impact cases escalate instead of disappearing in majority vote.
• Holm correction covers declared critical slices, and adversarial, multilingual, compressed, and transformed sets remain separate so daily volume is never mistaken for power.

I would schedule weighted modality work and the reviewer queue as separate capacity problems.

• The suite totals 638,000 GPU-seconds, or 177.2 GPU-hours; eight hours needs 22.2 busy GPUs, about 34 after 80% utilization and 20% reserve.
• Dedicated pools prevent 450,000 GPU-seconds of video work from blocking text and image, while the critical path tracks queued GPU-seconds rather than tests per second.
• Two thousand escalations require 100 reviewer-hours, so at least 13 concurrent reviewers are needed, plus coverage for disagreement and breaks.
• Versioned scenarios retain seed, mutation, manifest, detector output, artifact hash, and oracle decision; a severe slice or late human backlog fails release.

I would sign at the trusted export boundary and describe C2PA statements as claims, not permissions or proof that an edit occurred.

• The manifest binds output, parent ingredient, model and workflow identifiers, and claimed actions by the editor; verification checks signature chain, trust list, hard or soft binding, and ingredient relationship.
• HSM-backed signers use rotation and revocation, while an append-only certificate-event log is an internal control rather than a C2PA capability.
• Embedded manifests travel with supported images; video or audio sidecars use a signed package index and discovery URL bound to the asset, and absence returns unknown, not fake.
• About 23 signatures per second average is tested at ten-times peak and signer failover while preserving 99.99% attachment and the 80 ms p95 limit.

I would deploy watermarking as one probabilistic signal alongside C2PA provenance, never promise that it is indelible.

• A perceptual watermark is inserted before final encoding, with payload error correction and keys separated by product and epoch to limit compromise scope.
• Evaluation covers JPEG, resize, crop, blur, color edits, screenshots, regeneration, and adversarial removal, reporting recall and false-positive confidence bounds per transform.
• The 95% recall target applies only to the declared transform suite and quality range; outside it the verifier returns unknown rather than authentic or fake.
• C2PA provides signed positive provenance when retained, while watermark detection supports investigation and abuse response without becoming sole enforcement evidence.

Consent becomes revocable authorization bound to a verified speaker, and the statistical gate uses only consent-negative attempts.

• Enrollment combines account verification, randomized-phrase liveness, declared uses, expiry, and revocation; synthesis needs a short-lived capability matching tenant, speaker, model, and purpose.
• Samples and embeddings are encrypted, tenant-scoped, retention-limited, and excluded from general training, while high-risk policy can still block a matched voice.
• Testing 0.2% against the 0.5% ceiling needs about 3,400 independent negative attempts per critical slice by approximation; exact binomial simulation fixes final n and allowed approvals.
• Speaker and attack-family clusters cover spoof, replay, synthetic, multilingual, and accessibility slices with Holm-adjusted upper bounds; uncertainty returns review, not approval.