Design a multilingual NLP platform for 12 product teams, 20 languages, and 50 million documents per day with 99.9% availability and a $180,000 monthly budget.

I would build shared ingestion, training, evaluation, registry, and serving layers while keeping task-specific models behind stable contracts. - Kafka and Spark would normalize documents once, preserve raw text, language, tenant, and provenance, then publish versioned features for classification, NER, and search. - A platform API would expose asynchronous batch jobs and low-latency endpoints, with quotas and isolated Kubernetes namespaces so one team's traffic cannot exhaust another's capacity. - XLM-R provides the multilingual baseline, but high-volume languages can earn dedicated encoders only when slice metrics justify their extra ownership cost. - I would allocate the budget by measured CPU and GPU hours per team and gate releases on per-language quality, p99 latency, and rollback readiness.

Ten teams need to add 30 NLP tasks over 12 months, but the platform team has 6 engineers and must keep integration time below 2 weeks per task. How would you define the architecture contracts?

I would standardize data, model, evaluation, and serving contracts rather than force every task into one model. - Each task package declares input schema, label schema, tokenizer, model artifact, calibration policy, and metrics in a versioned manifest validated in CI. - Shared SDKs handle tracing, batching, feature validation, and registry access, while task teams own labels, acceptance thresholds, and error analysis. - Backward-compatible REST and batch interfaces hide PyTorch, spaCy, or ONNX implementation details, so a model can change without ten client migrations. - A reference task and contract tests make the 2-week target measurable, and exceptions require an architecture review with an explicit maintenance owner.

Design document classification for 80 million documents per day, 120 labels, 6 languages, a 30-minute batch SLA, and a compute budget of $0.20 per 1,000 documents.

I would use a two-stage classifier so cheap sparse features handle obvious documents and a compact multilingual encoder handles uncertain cases. - Spark performs normalization and TF-IDF inference in partitioned batches, sending only low-margin examples to a distilled XLM-R classifier. - The label head supports calibrated multilabel probabilities, and thresholds are tuned per label against business precision and recall costs rather than fixed at 0.5. - ONNX Runtime on CPU serves both stages in large batches, with GPU capacity reserved only if a measured batch benchmark beats the cost target. - Throughput, queue age, macro-F1, and per-language recall are release and operational gates, with the old artifact available for immediate batch replay.

A real-time support classifier must handle 6,000 requests per second across 8 languages, keep p99 below 80 ms, reach macro-F1 0.88, and run on 160 CPU cores. What would you deploy?

I would deploy a distilled multilingual encoder in ONNX with a rules-based fast path for exact high-confidence patterns. - Requests are language-routed, length-bucketed, and dynamically batched for at most 8 ms so throughput improves without consuming the 80 ms latency budget. - INT8 quantization is accepted only if every language loses under 0.5 F1 points, and long inputs are truncated using task-specific section priorities rather than raw character count. - Kubernetes replicas scale on concurrent requests and batch wait time, while overload enters a bounded queue and then returns a retryable rejection or an explicit abstention route, never a fabricated fallback label. - I would benchmark actual core saturation and p99 by length bucket before deciding whether a small GPU pool is cheaper than 160 CPU cores.

Design nested NER for 40 million legal pages per month with 35 entity types, nesting depth up to 3, span-F1 above 0.90, and review capacity of 20 annotators.

I would use a span-classification encoder because flat BIO tagging cannot represent the required nesting. - Candidate spans are pruned by maximum length and boundary scores, then classified with type-specific thresholds to control the quadratic span cost. - Annotation stores every span with parent links and explicit overlap rules, and 10% double annotation measures agreement by entity type and nesting depth. - Evaluation reports exact and partial span-F1, with separate slices for scanned pages, long clauses, and depth-3 entities so aggregate quality cannot hide failures. - The production pipeline preserves character offsets through OCR normalization and sends low-confidence or structurally invalid outputs to the 20-person review queue.

You must extract 18 entity types and 12 relation types from 30 million contracts per quarter, finish each nightly batch in 6 hours, and keep false obligations below 1%. How would you design the system?

I would separate candidate entity extraction from relation classification and optimize the obligation class for precision. - A domain encoder produces spans first, then a relation model scores only type-compatible pairs within the same clause or linked section to avoid combinatorial growth. - Deterministic contract rules validate dates, amounts, and required argument roles, but they reject impossible structures rather than invent missing model outputs. - Spark partitions by contract and batches similar lengths on GPUs, while OCR and parsing artifacts are cached so model reruns do not repeat ingestion work. - Release gates include exact span-F1, relation F1, obligation precision above 99%, and a blinded review of at least 1,000 contracts.

Design entity resolution for 250 million customer records written in Latin, Cyrillic, Arabic, and Han scripts, with 2 million updates per day, precision above 99.5%, and a 4-hour reconciliation SLA.

I would build blocking, multilingual candidate scoring, and conservative cluster assignment as separate stages. - Blocking uses normalized phones, emails, transliterated name keys, and locality-aware phonetic features, with multiple keys to preserve recall across scripts. - A pairwise model combines character encoders, address features, and exact identifiers, then calibrates thresholds by country and script because score distributions differ. - Cluster merges require transitive consistency and strong evidence, while ambiguous pairs remain unmerged for review because a false merge is harder to reverse than a miss. - Daily updates recompute only affected blocks and clusters, with sampled clerical review measuring pair precision and cluster purity before promotion.

Design hierarchical classification into a taxonomy of 4,000 nodes and 7 levels for 10 million product descriptions per day, with top-level accuracy above 98% and leaf macro-F1 above 0.75.

I would use a hierarchy-aware encoder with constrained decoding so every predicted leaf has a valid ancestor path. - A shared text encoder feeds level-specific heads, and training loss weights rare leaves while preserving abundant top-level supervision. - Inference prunes to the top candidate branches at each level, reducing 4,000-way scoring and making confidence available at every decision point. - Evaluation reports path accuracy, hierarchical F1, top-level accuracy, and leaf macro-F1, including zero-result coverage when confidence is too low. - Taxonomy nodes carry immutable IDs and effective dates so label renames do not corrupt training history or downstream analytics.

A multilabel classifier has 600 labels, 15 labels per document on average, 2 million labeled examples, and a p95 target of 120 ms at 1,500 requests per second. How would you handle imbalance and serving?

I would combine a shared encoder with label-aware candidate generation and per-label calibration. - Frequent labels train with asymmetric loss or controlled negative sampling, while rare labels receive targeted annotation instead of arbitrary oversampling. - A lightweight candidate head narrows 600 labels to about 50, then a richer scoring head evaluates only those candidates within the latency target. - Thresholds are selected per label from precision-recall curves and constrained by minimum support, with an abstention path for underrepresented labels. - ONNX dynamic batching and length buckets are benchmarked at 1,500 requests per second, and macro-F1 plus label coverage block release.

Five business units change a 2,500-label taxonomy every week, while 300 million historical documents must remain reproducible and new labels must be live within 24 hours. How would you manage taxonomy evolution?

I would version the taxonomy independently from model artifacts and make every prediction reference both versions. - Stable node IDs survive renames, while splits, merges, deprecations, and parent changes are recorded as explicit mappings with effective timestamps. - Training snapshots materialize labels under one taxonomy version; they never silently rewrite history when the business hierarchy changes. - A compatibility layer can map old predictions to new parents for reporting, but split leaves require reclassification because no deterministic mapping exists. - Weekly releases run coverage and hierarchy-consistency tests, then shadow on recent traffic before the 24-hour promotion window.

Design extractive QA over 20 million policy passages in 6 languages, with no generated answers, p99 below 350 ms, exact match above 75%, and 2,000 queries per second.

I would retrieve a bounded candidate set and run an extractive span reader that can abstain when evidence is insufficient. - BM25 and a multilingual bi-encoder retrieve about 100 passages, reciprocal rank fusion narrows them, and a cross-encoder selects the top 8 for reading. - The reader predicts start, end, and no-answer scores, then returns the exact source span with document ID, offsets, and policy version. - Components have separate latency budgets and caches, with retrieval near 120 ms and batched reader inference near 180 ms at peak load. - Release gates cover retrieval recall, exact match, token F1, no-answer accuracy, and per-language source-attribution correctness.

Design semantic enterprise search over 100 million documents for 40,000 employees, 3,000 queries per second, p95 below 250 ms, and document-level access control.

I would use BM25, dense encoder retrieval, and a small cross-encoder reranker with authorization enforced before results are returned. - Separate lexical and vector indexes preserve exact identifiers and semantic matches, then reciprocal rank fusion builds a candidate pool of about 200 documents. - Tenant and ACL filters are compiled into index filters or shard selection before scoring, not applied after retrieving unauthorized content. - The reranker scores only the top 50 candidates under a fixed latency budget, and snippets come from matched source spans rather than generated text. - Search quality is measured with NDCG@10, recall@50, zero-result rate, and per-department slices using judged queries from real employees.

A semantic search service handles 5,000 queries per second and has 70 ms left for reranking 200 candidates, with a budget of 8 A10 GPUs. How would you choose the reranker architecture?

I would reject an ordinary cross-encoder over 50 candidates unless a hardware benchmark disproves the capacity math. - At 5,000 queries per second, 50 candidates require 250,000 pair scores per second, or 31,250 per A10 before headroom, which is not realistic for an ordinary cross-encoder. - I would apply late interaction or a distilled lightweight reranker to all 200 candidates, then reserve the cross-encoder for a much smaller top set such as 8. - Offline tests compare NDCG@10 across candidate widths and hard query slices so reducing the final set is justified by measured relevance, not latency alone. - The release gate is measured peak throughput and p99 below 70 ms on all 8 A10 GPUs with production sequence lengths and at least 30% capacity headroom; otherwise I reject the hardware target.

Design sentence-level deduplication for 2 billion sentences in 14 languages, with 95% duplicate recall, less than 0.5% false merges, and a 12-hour Spark window.

I would combine exact hashing, locality-sensitive candidate generation, and a multilingual similarity model. - Unicode-normalized exact hashes and MinHash remove exact and near-shingle duplicates cheaply before any encoder work. - Remaining sentences receive compact multilingual embeddings, then language-aware ANN or LSH blocks produce candidate pairs instead of an all-pairs comparison. - A calibrated pair classifier confirms candidates, using stricter thresholds for short sentences where generic phrases create false merges. - Spark partitions by hash buckets and language, while a human-labeled pair set gates duplicate recall and the 0.5% false-merge limit.

A news archive receives 5 million articles per day and must link near-duplicates within 10 minutes across 12 languages while retaining 3 years of clusters. How would you design incremental similarity matching?

I would maintain a time-partitioned multilingual embedding index plus durable cluster metadata. - Exact URL and content hashes eliminate retries first, then new article embeddings search recent partitions and selected evergreen clusters for semantic candidates. - A pair model combines title, body, source, timestamp, and named-entity overlap, with thresholds calibrated per language and article length. - Cluster assignment is append-only with explicit merge records so mistaken joins can be reversed without rebuilding 3 years of history. - Kafka carries new articles, stream processors meet the 10-minute SLA, and a nightly reconciliation job catches candidates missed during index lag.

Design machine translation for 8 language pairs, 100 million characters per day, p95 below 900 ms for interactive text, COMET above 0.82, and a $90,000 monthly GPU budget.

I would use one multilingual encoder-decoder baseline with dedicated models only for pairs whose quality or volume justifies them. - Training data is deduplicated, language-pair balanced, domain-tagged, and filtered by alignment quality before supervised seq2seq training. - Interactive requests use TensorRT dynamic batching with a short wait, while large files enter a throughput-optimized batch queue on the same versioned models. - Evaluation combines COMET, BLEU, terminology accuracy, and blinded human adequacy and fluency reviews for every pair and domain. - Capacity planning allocates warm GPU replicas by pair traffic, with CPU fallback for low-volume pairs only after confirming the 900 ms target.

Design abstractive summarization for 5 million financial reports per month, each up to 20,000 words, with summaries under 300 words, 98% numeric consistency, and a 6-hour nightly SLA.

I would use a specialized encoder-decoder summarizer with hierarchical document encoding and explicit numeric validation. - Reports are segmented by structural headings, section representations are combined, and the decoder is trained only on approved report-summary pairs. - A copy mechanism or constrained number vocabulary reduces numeric mutations, and deterministic validators bind each number to its entity, reporting period, currency, and unit before comparing it with the source. - Evaluation includes ROUGE for coverage, factual consistency tests, numeric consistency above 98%, and blinded analyst ratings on at least 500 reports per release. - Spark schedules length-bucketed GPU batches, while reports failing validation are withheld for human review rather than automatically published.

A medical translation system covers 4 language pairs, 18,000 mandatory terms, 20 requests per second, and must keep terminology accuracy above 99% with p95 below 1.2 seconds. How would you enforce terminology?

I would combine domain-adapted seq2seq training with terminology-aware constrained decoding and source-side term detection. - The termbase is versioned by language pair, specialty, and effective date, with morphology-aware variants rather than literal string replacement. - Training mixes parallel medical text and synthetic term-focused examples, but evaluation keeps patient documents and term lists from the same source out of the test split. - At inference, detected terms bias or constrain the decoder only where alignment is confident, avoiding ungrammatical forced substitutions. - Release gates include COMET, clinician review, 99% terminology accuracy, and latency measured with worst-case term density.

Design an annotation platform for 300 annotators, 6 languages, 4 NLP teams, 2 million items per quarter, and 99.95% uptime during business hours.

I would build a multi-tenant task system with versioned schemas, assignment workflows, quality controls, and immutable annotation events. - Task definitions support spans, nested entities, relations, multilabel classes, and QA spans without forcing teams into free-form JSON. - A scheduler balances language skill, reviewer certification, gold items, and target double-annotation rates while preventing annotators from seeing test data. - Every edit records annotator, guideline version, timestamp, and source-data version, enabling adjudication and reproducible dataset exports. - Queue depth, save latency, disagreement, gold accuracy, and export freshness are monitored separately for each team and language.

Twenty annotators label nested entities in 3 languages, agreement is 0.61, the target is 0.80 within 4 weeks, and only 160 expert hours are available. How would you redesign guidelines and adjudication?

I would spend the expert hours on the highest-volume disagreement patterns and turn each resolution into a testable guideline example. - A disagreement matrix by entity type, boundary, nesting, and language identifies whether the problem is ambiguity, translation, or tool behavior. - Two experts adjudicate a stratified sample together, then publish positive, negative, and boundary examples under a new immutable guideline version. - Annotators complete a certification set and receive weekly feedback; production items remain double-labeled until each language exceeds the 0.80 target. - Agreement is measured with span-aware F1 and type-specific scores, not a single token-level number that hides nested-boundary errors.

NLP Engineer interview questions

100 real questions with model answers and explanations for Senior NLP Engineer candidates.

See a NLP Engineer resume example →

Practice with flashcards

Spaced repetition · Hunter Pass

Questions

nlpdesign

I would build shared ingestion, training, evaluation, registry, and serving layers while keeping task-specific models behind stable contracts.

Kafka and Spark would normalize documents once, preserve raw text, language, tenant, and provenance, then publish versioned features for classification, NER, and search.
A platform API would expose asynchronous batch jobs and low-latency endpoints, with quotas and isolated Kubernetes namespaces so one team's traffic cannot exhaust another's capacity.
XLM-R provides the multilingual baseline, but high-volume languages can earn dedicated encoders only when slice metrics justify their extra ownership cost.
I would allocate the budget by measured CPU and GPU hours per team and gate releases on per-language quality, p99 latency, and rollback readiness.

Why interviewers ask this: The interviewer is evaluating whether the candidate can separate reusable NLP infrastructure from task-specific ownership at organizational scale.

nlparchitecture

I would standardize data, model, evaluation, and serving contracts rather than force every task into one model.

Each task package declares input schema, label schema, tokenizer, model artifact, calibration policy, and metrics in a versioned manifest validated in CI.
Shared SDKs handle tracing, batching, feature validation, and registry access, while task teams own labels, acceptance thresholds, and error analysis.
Backward-compatible REST and batch interfaces hide PyTorch, spaCy, or ONNX implementation details, so a model can change without ten client migrations.
A reference task and contract tests make the 2-week target measurable, and exceptions require an architecture review with an explicit maintenance owner.

Why interviewers ask this: A strong answer defines concrete ownership boundaries and interfaces that let a small platform team support many heterogeneous NLP tasks.

designbatchclassification

I would use a two-stage classifier so cheap sparse features handle obvious documents and a compact multilingual encoder handles uncertain cases.

Spark performs normalization and TF-IDF inference in partitioned batches, sending only low-margin examples to a distilled XLM-R classifier.
The label head supports calibrated multilabel probabilities, and thresholds are tuned per label against business precision and recall costs rather than fixed at 0.5.
ONNX Runtime on CPU serves both stages in large batches, with GPU capacity reserved only if a measured batch benchmark beats the cost target.
Throughput, queue age, macro-F1, and per-language recall are release and operational gates, with the old artifact available for immediate batch replay.

Why interviewers ask this: The interviewer is checking architecture, calibration, and compute economics for high-volume discriminative NLP.

latencydeployment

I would deploy a distilled multilingual encoder in ONNX with a rules-based fast path for exact high-confidence patterns.

Requests are language-routed, length-bucketed, and dynamically batched for at most 8 ms so throughput improves without consuming the 80 ms latency budget.
INT8 quantization is accepted only if every language loses under 0.5 F1 points, and long inputs are truncated using task-specific section priorities rather than raw character count.
Kubernetes replicas scale on concurrent requests and batch wait time, while overload enters a bounded queue and then returns a retryable rejection or an explicit abstention route, never a fabricated fallback label.
I would benchmark actual core saturation and p99 by length bucket before deciding whether a small GPU pool is cheaper than 160 CPU cores.

Why interviewers ask this: The answer should connect model compression, batching, overload behavior, and multilingual quality to a strict CPU latency envelope.

designcapacity

I would use a span-classification encoder because flat BIO tagging cannot represent the required nesting.

Candidate spans are pruned by maximum length and boundary scores, then classified with type-specific thresholds to control the quadratic span cost.
Annotation stores every span with parent links and explicit overlap rules, and 10% double annotation measures agreement by entity type and nesting depth.
Evaluation reports exact and partial span-F1, with separate slices for scanned pages, long clauses, and depth-3 entities so aggregate quality cannot hide failures.
The production pipeline preserves character offsets through OCR normalization and sends low-confidence or structurally invalid outputs to the 20-person review queue.

Why interviewers ask this: The interviewer wants a representation and data workflow that genuinely support nested spans rather than flattening the requirement.

system-designdesignbatch

I would separate candidate entity extraction from relation classification and optimize the obligation class for precision.

A domain encoder produces spans first, then a relation model scores only type-compatible pairs within the same clause or linked section to avoid combinatorial growth.
Deterministic contract rules validate dates, amounts, and required argument roles, but they reject impossible structures rather than invent missing model outputs.
Spark partitions by contract and batches similar lengths on GPUs, while OCR and parsing artifacts are cached so model reruns do not repeat ingestion work.
Release gates include exact span-F1, relation F1, obligation precision above 99%, and a blinded review of at least 1,000 contracts.

Why interviewers ask this: A strong candidate decomposes information extraction, constrains relation candidates, and treats the costly false-positive class explicitly.

reactdesign

I would build blocking, multilingual candidate scoring, and conservative cluster assignment as separate stages.

Blocking uses normalized phones, emails, transliterated name keys, and locality-aware phonetic features, with multiple keys to preserve recall across scripts.
A pairwise model combines character encoders, address features, and exact identifiers, then calibrates thresholds by country and script because score distributions differ.
Cluster merges require transitive consistency and strong evidence, while ambiguous pairs remain unmerged for review because a false merge is harder to reverse than a miss.
Daily updates recompute only affected blocks and clusters, with sampled clerical review measuring pair precision and cluster purity before promotion.

Why interviewers ask this: The interviewer is evaluating whether the candidate understands multilingual blocking, asymmetric merge risk, and incremental clustering.

classificationdesign

I would use a hierarchy-aware encoder with constrained decoding so every predicted leaf has a valid ancestor path.

A shared text encoder feeds level-specific heads, and training loss weights rare leaves while preserving abundant top-level supervision.
Inference prunes to the top candidate branches at each level, reducing 4,000-way scoring and making confidence available at every decision point.
Evaluation reports path accuracy, hierarchical F1, top-level accuracy, and leaf macro-F1, including zero-result coverage when confidence is too low.
Taxonomy nodes carry immutable IDs and effective dates so label renames do not corrupt training history or downstream analytics.

Why interviewers ask this: The interviewer wants the hierarchy reflected in modeling, inference, metrics, and taxonomy lifecycle rather than treated as flat classification.

model-serving

I would combine a shared encoder with label-aware candidate generation and per-label calibration.

Frequent labels train with asymmetric loss or controlled negative sampling, while rare labels receive targeted annotation instead of arbitrary oversampling.
A lightweight candidate head narrows 600 labels to about 50, then a richer scoring head evaluates only those candidates within the latency target.
Thresholds are selected per label from precision-recall curves and constrained by minimum support, with an abstention path for underrepresented labels.
ONNX dynamic batching and length buckets are benchmarked at 1,500 requests per second, and macro-F1 plus label coverage block release.

Why interviewers ask this: A strong answer addresses extreme label imbalance, calibrated multilabel decisions, and scalable inference together.

reproducibility

I would version the taxonomy independently from model artifacts and make every prediction reference both versions.

Stable node IDs survive renames, while splits, merges, deprecations, and parent changes are recorded as explicit mappings with effective timestamps.
Training snapshots materialize labels under one taxonomy version; they never silently rewrite history when the business hierarchy changes.
A compatibility layer can map old predictions to new parents for reporting, but split leaves require reclassification because no deterministic mapping exists.
Weekly releases run coverage and hierarchy-consistency tests, then shadow on recent traffic before the 24-hour promotion window.

Why interviewers ask this: The interviewer is testing whether taxonomy changes are treated as versioned data contracts rather than ad hoc label edits.

queriesdesignlatency

I would retrieve a bounded candidate set and run an extractive span reader that can abstain when evidence is insufficient.

BM25 and a multilingual bi-encoder retrieve about 100 passages, reciprocal rank fusion narrows them, and a cross-encoder selects the top 8 for reading.
The reader predicts start, end, and no-answer scores, then returns the exact source span with document ID, offsets, and policy version.
Components have separate latency budgets and caches, with retrieval near 120 ms and batched reader inference near 180 ms at peak load.
Release gates cover retrieval recall, exact match, token F1, no-answer accuracy, and per-language source-attribution correctness.

Why interviewers ask this: The interviewer wants a complete retrieval plus extractive reading design that never crosses into generative answering.

queriesdesign

I would use BM25, dense encoder retrieval, and a small cross-encoder reranker with authorization enforced before results are returned.

Separate lexical and vector indexes preserve exact identifiers and semantic matches, then reciprocal rank fusion builds a candidate pool of about 200 documents.
Tenant and ACL filters are compiled into index filters or shard selection before scoring, not applied after retrieving unauthorized content.
The reranker scores only the top 50 candidates under a fixed latency budget, and snippets come from matched source spans rather than generated text.
Search quality is measured with NDCG@10, recall@50, zero-result rate, and per-department slices using judged queries from real employees.

Why interviewers ask this: A strong answer balances lexical and semantic retrieval while keeping authorization in the retrieval path.

retrievalrerankingarchitecture

I would reject an ordinary cross-encoder over 50 candidates unless a hardware benchmark disproves the capacity math.

At 5,000 queries per second, 50 candidates require 250,000 pair scores per second, or 31,250 per A10 before headroom, which is not realistic for an ordinary cross-encoder.
I would apply late interaction or a distilled lightweight reranker to all 200 candidates, then reserve the cross-encoder for a much smaller top set such as 8.
Offline tests compare NDCG@10 across candidate widths and hard query slices so reducing the final set is justified by measured relevance, not latency alone.
The release gate is measured peak throughput and p99 below 70 ms on all 8 A10 GPUs with production sequence lengths and at least 30% capacity headroom; otherwise I reject the hardware target.

Why interviewers ask this: The interviewer is checking whether reranker depth and architecture are selected from a quality-latency-capacity curve.

queriesdesignspark

I would combine exact hashing, locality-sensitive candidate generation, and a multilingual similarity model.

Unicode-normalized exact hashes and MinHash remove exact and near-shingle duplicates cheaply before any encoder work.
Remaining sentences receive compact multilingual embeddings, then language-aware ANN or LSH blocks produce candidate pairs instead of an all-pairs comparison.
A calibrated pair classifier confirms candidates, using stricter thresholds for short sentences where generic phrases create false merges.
Spark partitions by hash buckets and language, while a human-labeled pair set gates duplicate recall and the 0.5% false-merge limit.

Why interviewers ask this: The interviewer wants a scalable candidate-generation design and explicit protection against destructive false merges.

dedupdesign

I would maintain a time-partitioned multilingual embedding index plus durable cluster metadata.

Exact URL and content hashes eliminate retries first, then new article embeddings search recent partitions and selected evergreen clusters for semantic candidates.
A pair model combines title, body, source, timestamp, and named-entity overlap, with thresholds calibrated per language and article length.
Cluster assignment is append-only with explicit merge records so mistaken joins can be reversed without rebuilding 3 years of history.
Kafka carries new articles, stream processors meet the 10-minute SLA, and a nightly reconciliation job catches candidates missed during index lag.

Why interviewers ask this: A strong answer separates low-latency incremental matching from durable and reversible cluster maintenance.

designhardware

I would use one multilingual encoder-decoder baseline with dedicated models only for pairs whose quality or volume justifies them.

Training data is deduplicated, language-pair balanced, domain-tagged, and filtered by alignment quality before supervised seq2seq training.
Interactive requests use TensorRT dynamic batching with a short wait, while large files enter a throughput-optimized batch queue on the same versioned models.
Evaluation combines COMET, BLEU, terminology accuracy, and blinded human adequacy and fluency reviews for every pair and domain.
Capacity planning allocates warm GPU replicas by pair traffic, with CPU fallback for low-volume pairs only after confirming the 900 ms target.

Why interviewers ask this: The interviewer is evaluating specialized seq2seq architecture, multilingual allocation, human evaluation, and serving economics.

designconsistency

I would use a specialized encoder-decoder summarizer with hierarchical document encoding and explicit numeric validation.

Reports are segmented by structural headings, section representations are combined, and the decoder is trained only on approved report-summary pairs.
A copy mechanism or constrained number vocabulary reduces numeric mutations, and deterministic validators bind each number to its entity, reporting period, currency, and unit before comparing it with the source.
Evaluation includes ROUGE for coverage, factual consistency tests, numeric consistency above 98%, and blinded analyst ratings on at least 500 reports per release.
Spark schedules length-bucketed GPU batches, while reports failing validation are withheld for human review rather than automatically published.

Why interviewers ask this: A strong answer treats summarization as a controlled seq2seq task with document structure, source checks, and domain human review.

system-design

I would combine domain-adapted seq2seq training with terminology-aware constrained decoding and source-side term detection.

The termbase is versioned by language pair, specialty, and effective date, with morphology-aware variants rather than literal string replacement.
Training mixes parallel medical text and synthetic term-focused examples, but evaluation keeps patient documents and term lists from the same source out of the test split.
At inference, detected terms bias or constrain the decoder only where alignment is confident, avoiding ungrammatical forced substitutions.
Release gates include COMET, clinician review, 99% terminology accuracy, and latency measured with worst-case term density.

Why interviewers ask this: The interviewer wants a concrete terminology architecture that preserves grammatical translation and validates specialist quality.

nlpdesign

I would build a multi-tenant task system with versioned schemas, assignment workflows, quality controls, and immutable annotation events.

Task definitions support spans, nested entities, relations, multilabel classes, and QA spans without forcing teams into free-form JSON.
A scheduler balances language skill, reviewer certification, gold items, and target double-annotation rates while preventing annotators from seeing test data.
Every edit records annotator, guideline version, timestamp, and source-data version, enabling adjudication and reproducible dataset exports.
Queue depth, save latency, disagreement, gold accuracy, and export freshness are monitored separately for each team and language.

Why interviewers ask this: The interviewer is checking whether annotation is designed as reliable data infrastructure rather than a simple labeling screen.

I would spend the expert hours on the highest-volume disagreement patterns and turn each resolution into a testable guideline example.

A disagreement matrix by entity type, boundary, nesting, and language identifies whether the problem is ambiguity, translation, or tool behavior.
Two experts adjudicate a stratified sample together, then publish positive, negative, and boundary examples under a new immutable guideline version.
Annotators complete a certification set and receive weekly feedback; production items remain double-labeled until each language exceeds the 0.80 target.
Agreement is measured with span-aware F1 and type-specific scores, not a single token-level number that hides nested-boundary errors.

Why interviewers ask this: A strong answer converts limited expert time into measurable guideline and certification improvements.

Locked questions

21
You have 1 million unlabeled tickets, budget for 50,000 annotations, 80 labels, 5 languages, and 8 weeks to improve macro-F1 from 0.72 to 0.82. How would you use active learning?
22
Build a training corpus from 20 sources totaling 4 TB and 9 billion sentences, with exact provenance, less than 2% duplication, and a 24-hour preprocessing SLA on 200 Spark workers.
spark
23
A 6-language corpus contains 600 million support messages, must remove 99.9% of emails and phone numbers, preserve entity-label offsets, and complete within 18 hours under GDPR controls. How would you process it?
gdprconcurrency
24
Design language routing for 15 languages when 20% of 8,000 requests per second are code-switched, p99 routing latency must stay below 12 ms, and wrong routing must remain under 1%.
latencydesign
25
Three new languages have only 20,000 labeled examples each, 2 million unlabeled sentences, 10 weeks of work, and a 4-engineer team targeting NER F1 above 0.80. What strategy would you choose?
26
You have 8 billion in-domain tokens, 32 A100 GPUs for 72 hours, and 6 downstream classification and NER tasks that lag the general BERT baseline by 5 F1 points. How would you run domain-adaptive pretraining?
classificationtokensbert
27
Twelve business domains each need a document classifier, labeled data ranges from 30,000 to 3 million examples, the team has 8 GPUs, and all models must ship in 6 weeks. How would you structure encoder fine-tuning?
fine-tuning
28
Nine NLP tasks across classification, NER, and extractive QA share 3 languages, but serving separate encoders costs $140,000 per month and the target is $80,000 with under 1 F1 point average loss. Would you build a multi-task model?
classificationnlpmodel-serving
29
A 340 million parameter XLM-R classifier reaches macro-F1 0.91 but costs $110,000 per month; the target is $55,000 with no language losing more than 1 point across 10 languages. How would you distill it?
30
Fine-tune XLM-R on 900 million labeled tokens using 16 A100 GPUs within 24 hours, with at most 30 minutes of lost work after a node failure. How would you configure distributed training?
fine-tuningtokensdistributed
31
Train a 1.2 billion parameter translation model on 64 A100 GPUs, 40 language directions, and 6 trillion parallel tokens within 5 days, while checkpoints may lose at most 20 minutes. What architecture would you use?
tokensarchitecture
32
Preprocess 40 TB of multilingual web text on 500 Spark workers in 16 hours, including language ID, sentence splitting, deduplication, and PII removal with under 1% failed records. How would you organize the job?
queriespiispark
33
You need 500 encoder fine-tuning trials across 7 tasks in 10 days, have 12 GPUs and a $35,000 compute cap, and must preserve reproducibility. How would you use Ray?
fine-tuningray
34
Design a Kafka pipeline for 15,000 documents per second, 10 NLP enrichments, end-to-end p95 below 45 seconds, and no duplicate records in the search index after retries.
kafkadesignindexes
35
A nightly NLP batch must classify 600 million records in 8 hours across 5 regions, keep data within each region, and cost under $12,000 per run. How would you schedule it?
nlpbatch
36
Serve a 110 million parameter BERT classifier at 12,000 requests per second on 240 CPU cores, with p99 below 60 ms and accuracy loss below 0.5 points. How would you optimize it?
optimizationlatencybert
37
Serve XLM-R for 6 languages at 4,000 requests per second, p99 below 100 ms, on 8 A10 GPUs with 99.95% availability. How would you use TensorRT and Kubernetes?
serving-runtimeskuberneteslatency
38
A spaCy pipeline with tokenization, rules, NER, and entity linking must process 50,000 short messages per second on 300 CPU cores with p95 below 40 ms. How would you package and scale it?
tokensconcurrencyci-cd
39
An encoder endpoint receives texts from 8 to 512 tokens at 10,000 requests per second, must keep p99 below 90 ms, and can use 6 GPUs. How would you design dynamic batching?
designbatchendpoints
40
Create a model registry and release process for 25 NLP models owned by 10 teams, with weekly releases, rollback under 10 minutes, and zero untraceable production predictions.
rollbackregistriesconcurrency
41
Define offline release gates for a classifier serving 18 languages and 6 demographic regions, with macro-F1 above 0.86 and no region-language slice allowed to regress more than 2 points.
model-serving
42
A 7-language NER model must retain at least 90% of clean-text F1 on OCR text with 8% character error rate, social text with 15% typos, and inputs up to 4,000 characters. How would you build robustness evaluation?
llm-eval
43
Design drift detection for 12 text classifiers handling 30 million predictions per day when verified labels arrive after 21 days and false alarms must stay below 2 per month.
designiac
44
Manage a semantic search index of 600 million embeddings, 4 million document updates per day, freshness under 15 minutes, recall@20 above 0.94, and no search downtime during encoder upgrades.
nlpembeddingsretrieval
45
Design real-time PII redaction for 25,000 messages per second in 10 languages, p99 below 45 ms, recall above 99.95% for regulated identifiers, and 30-day audit retention.
retentiondesignpii
46
A search product receives 200,000 feedback events per day from 30,000 users, but only 8 analysts can review them and taxonomy updates must ship monthly. How would you build a human-feedback taxonomy?
feedback
47
Plan capacity for 3 encoder services totaling 18,000 requests per second, p99 below 100 ms, 2 times peak headroom, and a $120,000 monthly limit across CPU and GPU options.
latencyhardwarecapacity
48
Deploy NER and classification in 5 regions for 14 languages, keep all text and embeddings in-region, meet 99.99% availability, and roll out one global model release within 48 hours. How would you design it?
classificationnlpembeddings
49
A bank must classify 60 fixed transaction descriptions at 20,000 requests per second, p99 below 20 ms, with 6 engineers, 12 weeks, and fewer than 0.1% critical errors. Would you use rules, a model, or both?
transactionslatency
50
Your 7-engineer team must review an architecture for nested NER over 25 million clinical notes per month, 4 languages, p95 below 150 ms, and a $70,000 monthly budget before implementation starts in 3 weeks. How would you lead the review and mentor the team?
mentoringarchitecture
51
A sentiment classifier loses 14 F1 points after a checkpoint rollout, and you have 90 minutes before peak traffic. The model hash is correct but the tokenizer came from the previous release. What do you do?
tokens
52
After enabling NFC normalization, search misses for Vietnamese names rise from 3% to 19% across 2 million daily queries, and a fix is due in four hours. How do you investigate?
normalizationqueries
53
An OCR parser update cuts invoice-field F1 from 91% to 63% on 80,000 scanned pages, while digital PDFs stay stable; finance needs recovery by tomorrow morning. What is your plan?
54
NER recall for 1,200 newly launched product names is 48% versus 89% for established products, and catalog search launches in 72 hours. How do you respond?
55
A clinical NER model misses 22% of new oncology drug names and medication reconciliation starts in 48 hours for 14 hospitals. What do you decide?
react
56
A label taxonomy migration splits Billing into Refund, Chargeback, and Invoice, but 38% of 9 million historical tickets still carry the old label; cutover is in six days. How do you migrate safely?
migrations
57
An entity-resolution release falsely merges 3.6% of 600,000 customer profiles with similar transliterated names, and compliance needs containment within two hours. What do you do?
58
A language-ID update misroutes 11% of Portuguese tickets to Spanish models, increasing resolution time by 27%; support needs a mitigation in three hours. What do you change?
59
A moderation classifier falls from 86% to 61% recall on Hindi-English code-switched posts during a 5 million-user event, and you have four hours to stabilize it. What is your response?
60
A multilingual classifier upgrade gains 3 macro-F1 points overall but drops Amharic F1 from 72% to 49%; launch is scheduled in 24 hours. Do you ship?
61
An annotation vendor reports 98% completion on 400,000 intent labels, but 31% of duplicated gold items have inconsistent labels; training starts in 36 hours. What do you do?
procurement
62
Three annotation teams disagree on whether symptoms in family history count as PatientCondition, yielding kappa 0.42 across 12,000 notes; guidelines must be frozen by Friday. How do you resolve it?
conflict
63
Zero-width characters and homoglyphs reduce a toxicity classifier's recall from 88% to 54% on 25,000 red-team texts four days before release. How do you respond?
64
A corpus audit finds names, phone numbers, and diagnoses in 2.4% of 18 million training sentences, and legal requires a decision within 24 hours. What do you do?
65
A multilingual PII redactor misses 17% of Arabic and Devanagari phone formats across 60 million requests, with a vendor export due tonight. How do you respond?
procurementpii
66
A toxicity model scores 90% F1 offline but only 74% in production after a preprocessing refactor; rollback must be decided in 60 minutes. How do you find train-serving skew?
refactoringrollbackmodel-serving
67
A news NER and entity-extraction system trained through 2024 loses 16 span-recall points on 2026 election entities over two weeks; editorial needs a plan by tomorrow. How do you handle temporal drift?
soft-skillssystem-designiac
68
A support intent model moved from consumer electronics to industrial equipment and macro-F1 fell from 88% to 59% on 70,000 tickets; the new queue opens in five days. What do you do?
data-structures
69
Lowering a fraud-text classifier threshold from 0.62 to 0.51 raises recall from 78% to 91% but blocks 14,000 legitimate appeals daily; leadership wants a choice in two hours. What do you decide?
thresholding
70
After class reweighting, intent accuracy stays at 87% but expected calibration error rises from 0.04 to 0.19, breaking an automated escalation policy in 24 hours. How do you recover?
calibrationescalation
71
A reading-comprehension release answers 34% of unanswerable policy questions instead of abstaining, up from 8%, and launch is tomorrow. What do you inspect?
comprehensions
72
A QA API returns correct answer text but wrong character offsets for 6.8% of 3 million documents after Unicode cleanup; clients need a patch in six hours. What do you do?
api
73
A sentence-deduplication release drops duplicate recall from 92% to 75% on paraphrased multilingual articles, allowing 18 million duplicates into a training corpus; the old pipeline retires in 48 hours. How do you respond?
queriesci-cd
74
Semantic search recall@50 stays at 94%, but precision@5 falls from 71% to 43% and zero-result reformulations rise 26%; product wants a fix by Monday. What do you change?
retrieval
75
A BM25 index rebuild changes the analyzer and exact SKU search success falls from 97% to 52% across 8 million products; rollback expires in three hours. What do you do?
bm25indexesrollback
76
During a semantic-search embedding migration, 18% of documents still use the old vector space and top-10 overlap swings from 82% to 37%; cutover is in five days. How do you recover?
nlpembeddingsmigrations
77
A multilingual reranker raises English nDCG@10 by 4 points but drops Japanese from 0.76 to 0.58 on 12,000 queries, and release is in 36 hours. What do you decide?
rerankingqueries
78
A machine-translation candidate improves BLEU from 31.2 to 34.8, but native reviewers prefer the old output in 64% of 500 legal sentences; a vendor switch is due Friday. What do you trust?
bleuprocurement
79
A financial summarizer's ROUGE stays stable, but 12% of 2,000 summaries attach correct numbers to the wrong quarter, entity, currency, or unit; automation starts in 72 hours. What do you do?
rouge
80
A translation release renders Chargeback as Refund in 17% of 90,000 German support messages, and customer notices go out in eight hours. How do you contain the terminology incident?
incidents
81
A clinical summarizer copies patient identifiers into 6.1% of discharge summaries despite a de-identification stage, and deployment is scheduled in 24 hours. What do you do?
deployment
82
A meeting summarizer omits 23% of assigned action items when transcripts exceed 45 minutes, and executives need a fix before tomorrow's 300 meetings. What do you change?
tracking
83
A Spark text job processing 12 TB now OOMs 7% of executors after adding language-specific tokenization, and the corpus is due in ten hours. How do you stabilize it?
tokensconcurrencyspark
84
Kafka lag reaches 38 million messages and duplicate text classifications rise to 4.5% after consumer rebalancing; the SLA must recover in two hours. What do you do?
classificationkafka
85
An Airflow DAG marks success although 14 of 320 corpus partitions never reached training, and a 48-GPU run starts in six hours. How do you respond?
partitioningairflowhardware
86
After subword alignment, some NER batches contain documents whose every label is ignore index -100; an 8-GPU run hits NaN at step 72,400 after 19 hours. How do you recover?
indexesbatchhardware
87
After resuming multilingual distributed training with a changed world size, overall loss matches but Swahili F1 drops 11 points because sampler epoch and RNG sharding starve that language; eight hours of the reservation remain. What do you do?
shardingdistributed
88
A model-registry release uses the correct checkpoint and tokenizer but the wrong id-to-label mapping swaps Refund and Chargeback on 1.2 million tickets; rollback is required in 45 minutes. What do you do?
rollbackregistriestokens
89
An ONNX export matches PyTorch accuracy overall but changes 5.2% of NER spans on 20,000 long sentences, and mobile release is in three days. How do you investigate?
serving-runtimespytorch
90
A TensorRT conversion cuts p95 latency from 92 ms to 41 ms but lowers document-classification recall from 88% to 79% for texts over 2,000 tokens; launch is in 48 hours. What do you do?
classificationtokenslatency
91
INT8 quantization halves encoder cost but drops Swahili intent F1 from 76% to 61% while English is unchanged; capacity runs out in 72 hours. Do you deploy it?
capacitydeploymentmodel-compression
92
Kubernetes p99 rises from 180 ms to 740 ms at 6,000 requests per second while GPUs stay at 43% and CPU tokenization hits 96%; you have one hour to stabilize service. What do you do?
tokenskuberneteslatency
93
A nightly classifier backlog grows to 84 million documents after a 29% throughput regression, and results are due in 11 hours. How do you recover?
throughputbacklog
94
Dynamic batching raises throughput 35% but pushes p99 latency from 240 ms to 910 ms for short texts at 4,500 requests per second; a launch review is in two hours. Keep it?
latencythroughputbatch
95
An encoder service OOMs when 40 users upload 12,000-token legal documents, although the supported limit is 16,000; customer filing closes in three hours. How do you stabilize it?
tokens
96
Your drift detector missed a 19-point recall loss for six days, then a replacement rule emits 430 alerts per hour on harmless slang changes; operations needs a decision today. What do you build?
alertingiac
97
An A/B test improves overall ticket automation by 6%, but false auto-closures for Arabic users rise from 2% to 9% after 48 hours; product wants the planned 100% rollout tomorrow. What do you decide?
ab-testingclosures
98
A customer requests deletion of 240,000 EU support messages used in training, but replicas and the model registry span US and EU regions; proof is due in 14 days. How do you execute it?
replicationregistries
99
In code review, a middle engineer proposes lowercasing, ASCII folding, and truncating every document to 512 tokens because the service exceeds its latency target by 20% before Friday. How do you review and mentor them after the change already broke Turkish intent F1 by 13 points?
mentoringcode-reviewlatency
100
Product asks for a Friday launch of a medical triage classifier covering 2 million users, but severe-condition recall is 81% against a 95% gate and rollback takes 40 minutes. What do you recommend at the final review?
rollback

Questions

1Design a multilingual NLP platform for 12 product teams, 20 languages, and 50 million documents per day with 99.9% availability and a $180,000 monthly budget.

2Ten teams need to add 30 NLP tasks over 12 months, but the platform team has 6 engineers and must keep integration time below 2 weeks per task. How would you define the architecture contracts?

3Design document classification for 80 million documents per day, 120 labels, 6 languages, a 30-minute batch SLA, and a compute budget of $0.20 per 1,000 documents.

4A real-time support classifier must handle 6,000 requests per second across 8 languages, keep p99 below 80 ms, reach macro-F1 0.88, and run on 160 CPU cores. What would you deploy?

5Design nested NER for 40 million legal pages per month with 35 entity types, nesting depth up to 3, span-F1 above 0.90, and review capacity of 20 annotators.

6You must extract 18 entity types and 12 relation types from 30 million contracts per quarter, finish each nightly batch in 6 hours, and keep false obligations below 1%. How would you design the system?

7Design entity resolution for 250 million customer records written in Latin, Cyrillic, Arabic, and Han scripts, with 2 million updates per day, precision above 99.5%, and a 4-hour reconciliation SLA.

8Design hierarchical classification into a taxonomy of 4,000 nodes and 7 levels for 10 million product descriptions per day, with top-level accuracy above 98% and leaf macro-F1 above 0.75.

9A multilabel classifier has 600 labels, 15 labels per document on average, 2 million labeled examples, and a p95 target of 120 ms at 1,500 requests per second. How would you handle imbalance and serving?

10Five business units change a 2,500-label taxonomy every week, while 300 million historical documents must remain reproducible and new labels must be live within 24 hours. How would you manage taxonomy evolution?

11Design extractive QA over 20 million policy passages in 6 languages, with no generated answers, p99 below 350 ms, exact match above 75%, and 2,000 queries per second.

12Design semantic enterprise search over 100 million documents for 40,000 employees, 3,000 queries per second, p95 below 250 ms, and document-level access control.

13A semantic search service handles 5,000 queries per second and has 70 ms left for reranking 200 candidates, with a budget of 8 A10 GPUs. How would you choose the reranker architecture?

14Design sentence-level deduplication for 2 billion sentences in 14 languages, with 95% duplicate recall, less than 0.5% false merges, and a 12-hour Spark window.

15A news archive receives 5 million articles per day and must link near-duplicates within 10 minutes across 12 languages while retaining 3 years of clusters. How would you design incremental similarity matching?

16Design machine translation for 8 language pairs, 100 million characters per day, p95 below 900 ms for interactive text, COMET above 0.82, and a $90,000 monthly GPU budget.

17Design abstractive summarization for 5 million financial reports per month, each up to 20,000 words, with summaries under 300 words, 98% numeric consistency, and a 6-hour nightly SLA.

18A medical translation system covers 4 language pairs, 18,000 mandatory terms, 20 requests per second, and must keep terminology accuracy above 99% with p95 below 1.2 seconds. How would you enforce terminology?

19Design an annotation platform for 300 annotators, 6 languages, 4 NLP teams, 2 million items per quarter, and 99.95% uptime during business hours.

20Twenty annotators label nested entities in 3 languages, agreement is 0.61, the target is 0.80 within 4 weeks, and only 160 expert hours are available. How would you redesign guidelines and adjudication?

Locked questions