Building Your First RAG System: Why Naive Retrieval Fails and How to Fix It
Picture a field technician kneeling beside a stalled pump at a customer site. She types "seal kit for 4471-B" into the new service assistant and gets a confident, cited answer about the 4417-B. Back at head office the engineers swap the model for the second time. Nothing improves, because much of what goes wrong in a RAG system goes wrong before the model ever sees the right passage. This lesson shows you where to look, how to name what you find, how to make retrieval respect who is asking, and how to fix the biggest fault first.
You are at Level 2 (AI Capable) of the L1 to L5 ladder, in the second of five lessons. The previous lesson, on fixing data quality one use case at a time, gave you a scoped set of sources, each with an owner and an access label, a data scorecard and a list of real questions. Here you put a retrieval pipeline on top of that data and learn to diagnose it. You will leave with a named artifact: the RAG Failure-Point Diagnosis and Pipeline Configuration Sheet. The next lesson, building a golden test set for LLM evaluation, turns the hand-judging you do here into a repeatable score.
Why a RAG System Still Makes Things Up, and What It Costs
Start with the people who should have got this right.
Legal research publishers have everything a RAG project could wish for: deep budgets, specialist engineers, and a corpus of case law and commentary that professional editors have curated for decades. No messy shared drive. No seventeen versions of the same policy. Two of the biggest names built AI research assistants on top of those libraries. LexisNexis marketed "hallucination-free" citations. Thomson Reuters described tools that "avoid" hallucinations.
Then researchers at Stanford RegLab and Stanford HAI tested the products with more than 200 legal queries written down in advance (pre-registered, so nobody could pick favourable questions afterwards). According to the Stanford HAI write-up of 23 May 2024, updated 30 May 2024, Lexis+ AI and Ask Practical Law AI each hallucinated on more than 17% of queries. Westlaw AI-Assisted Research hallucinated on more than 34%.
For two of the tools, more than 1 answer in 6 was wrong; for the third, more than 1 in 3. The vendors disputed aspects of the study at the time. The point holds anyway: a curated corpus and a serious engineering team did not produce a system that could be trusted without checking.
What is the difference between an incorrect answer and a misgrounded one?
An incorrect answer states something false. A misgrounded answer states something true but cites a source that does not support it. The Stanford team separated the two, and your team should adopt both words.
The second kind is the dangerous one. An incorrect answer with no citation makes a careful reader suspicious. A confident answer with a citation next to it makes the reader stop checking. The citation works like a signature on a form: people assume someone verified what sits above it. If the cited passage says something else, your system has manufactured false confidence, which is worse than none.
Does retrieval help at all?
Yes, a great deal. Earlier work by the same Stanford group found that general-purpose chatbots hallucinated on 58% to 82% of legal queries (as reported by Stanford HAI, May 2024). Going from that range to the high teens is a real improvement. It does not finish the job.
Stanford gives three reasons it does not. Retrieval can fail to find the right material. What it finds can be out of date or from the wrong jurisdiction. And the model can go along with a false premise baked into the question, a habit known as sycophancy. Notice that only the third has much to do with the model, which is why the engineers in the opening scene got nowhere by swapping it.
Three rules follow from the Stanford story. Retrieval reduces hallucination but does not remove it. A vendor's "hallucination-free" claim is a red flag, not a feature. And only tests on your own questions tell you how your system behaves.
The cost that finally reaches the business, liability for what the system says, is the subject of Lesson 8. Before you can measure it, you need a pipeline you can see inside.
How a RAG System Works: Find First, Then Write
Retrieval-augmented generation (RAG) is a pattern in which the system first fetches passages from your own documents and then asks a language model to answer using only those passages. Two stages: find, then write. Which means two places to fail, and they need different repairs.
The paralegal in the records room
Picture a new paralegal on their first week, working beside a large records room. You walk in and ask a question. They run to the shelves, grab five folders, come back and write you a memo from whatever those folders contain. The memo always sounds confident.
If the folder you needed was never filed, they do not come back empty-handed. They are new and eager, so they improvise from the nearest material. If they grabbed the five folders closest to your topic and the right one was sixth, the memo is wrong and nothing in it tells you so. If a loose page says "the company shall bear the cost" and the cover sheet is missing, they guess which company.
None of these is a writing problem. A better writing course would fix nothing, and that is exactly what swapping the model is.
A good records clerk behaves differently. They search by exact reference number and by topic. They pull thirty folders, not five, and have a senior colleague skim those down to the best few. They keep the cover sheet stapled to every page. They check your badge before they fetch anything. And when it is true, they say: "We do not hold that file."
Every fix below is one of the clerk's habits.
What is naive retrieval?
Naive retrieval is the one-method version: split each document into fixed-size pieces (chunks), convert each chunk into an embedding, and fetch the few chunks nearest to the question. An embedding is a list of numbers that captures roughly what a piece of text is about, so that passages on similar topics sit close together.
It is the eager paralegal, automated, with three built-in weaknesses:
- It is vague about exact terms. Similarity of meaning is poor at part numbers, error codes and names. "Pump seal kit 4471-B" and "pump seal kit 4417-B" look almost identical to a method that compares meaning.
- Chunks lose their cover sheet. A chunk cut from the middle of a document no longer says which product, which year or which policy it belongs to.
- The cut-off is brutal. If you pass the top five chunks and the right one ranked sixth, it might as well not exist.
What are the seven failure points of a RAG system?
They are seven named places where a RAG answer can go wrong, catalogued by researchers at Deakin University in "Seven Failure Points When Engineering a Retrieval Augmented Generation System" (Barnett and colleagues, arXiv, 11 January 2024). The paper drew on three case studies: a research assistant used by Deakin PhD students, an AI tutor built on 38 documents and piloted with 200 students, and a biomedical question set of 1,000 questions.
| Code | Name | Stage | In plain words | The records room version |
|---|---|---|---|---|
| FP1 | Missing content | Before generation | The answer is not in your documents, and the system answers anyway. | The folder was never filed. The paralegal improvises. |
| FP2 | Missed the top-ranked documents | Before generation | The answer exists but ranked below the cut-off. | The right folder was sixth and they took five. |
| FP3 | Not in context | Before generation | The passage was retrieved, then dropped when results were consolidated for the model. | They carried the folder back, then left it off the desk. |
| FP4 | Not extracted | Generation | The passage was in front of the model, which missed it amid noise or contradiction. | The page was on the desk under two older versions that disagreed. |
| FP5 | Wrong format | Generation | You asked for a table and got prose. | Right facts, wrong form. |
| FP6 | Incorrect specificity | Generation | The answer is too general or too detailed for the question. | You asked about one model and got the brochure. |
| FP7 | Incomplete | Generation | Part of the answer is missing although the material was available. | Two conditions apply. The memo lists one. |
Read down that list again and count. The first three failure points happen before the right passage ever reaches the model: in indexing, retrieval and consolidation, following the pipeline diagram in the paper. The fourth happens when the model has the passage and fails to use it, often because two contradictory versions sit beside it, which is a data fix rather than a model fix. That is why model-swapping so often changes nothing.
What are hybrid search, contextual chunks and reranking?
They are the three standard accuracy upgrades from naive retrieval, and each one is a habit of the good clerk.
- Hybrid search runs keyword matching (a method called BM25, which scores exact word overlap) and embedding similarity side by side, then merges the two rankings. The clerk searches by reference number and by topic.
- Contextual chunks each carry a short written note saying which document and section they came from. The cover sheet stays stapled on.
- Reranking casts a wide net first and then has a second model pick the best few from it. Thirty folders, skimmed down by a senior.
In "Contextual Retrieval" (Anthropic, 19 September 2024), the company measured how often a relevant chunk was missing from the top 20 results. With plain embeddings, 5.7%. With context added to each chunk (50 to 100 tokens per chunk), 3.7%, which is 35% fewer failures. With contextual keyword search added, 2.9%, or 49% fewer. With a reranker on top, taking the top 150 candidates down to 20, the figure was 1.9%, or 67% fewer.
Treat those figures with care: they are vendor-published, on Anthropic's own benchmarks, and your absolute rates will differ. What travels is the direction and rough size of the gain: each layer removed a meaningful share of what the previous layer missed.
Does better retrieval reach the business? A LinkedIn team built customer service retrieval on a knowledge graph of past tickets and reported in a paper on arXiv, 26 April 2024, presented at SIGIR 2024 that after about six months in use, median per-issue resolution time fell by 28.6%. It is a company-authored paper and a single case: evidence that it is possible, not a forecast.
Is more context always better?
No, and the evidence pulls both ways. The Deakin paper found a larger 8K context beat 4K. Anthropic found that passing 20 chunks beat passing 5 or 10. Yet Anthropic's context engineering guidance of 29 September 2025 describes "context rot": the model's ability to recall what is in its window declines gradually as the window fills.
So the paralegal with thirty folders writes a better memo than the one with five, and the one with three hundred writes a worse one. Your tipping point is found by measuring on your own questions, not by asking anyone.
When do you not need RAG at all?
When the knowledge base is small enough to hand over whole. Anthropic's rule of thumb (September 2024) is that if your knowledge base is under about 200,000 tokens, roughly 500 pages, you can put the entire thing in the prompt and skip retrieval. A token is a word-fragment, the unit models count text in.
If the whole records room fits in one briefcase, hand over the briefcase. Do not hire a clerk.
What is permission-aware retrieval?
Permission-aware retrieval means the search step only returns passages the person asking is allowed to open, checked at the moment of the search. Unlike the three upgrades above, it is not about accuracy. It stops a technician being told what only a service manager may know.
Back to the records room. A good clerk checks your badge before fetching folders, not after writing the memo. Once a restricted page is on the desk, asking the paralegal to leave it out of the memo is a hope, not a control. A passage that reaches the model's context window can reach the answer, whatever the prompt says. So the check belongs in retrieval, as a filter applied before ranking, using the access label every source received in Lesson 6.
The permissions underneath matter as much as the filter. Microsoft's foundational deployment guidance for Copilot (Microsoft Learn, last updated 30 October 2026) describes Copilot as "grounding responses in the data users already have permission to access", and its framework is to "reduce Copilot exposure quickly, then harden your environment", starting with oversharing. Follow the logic: if retrieval honours permissions faithfully, every overshared folder becomes an overshared answer. The OWASP Top 10 for LLM Applications 2026 (OWASP GenAI Security Project, August 2026) lists Sensitive Information Disclosure at LLM02 and Vector and Embedding Weaknesses at LLM09. The Level 3 lesson on defending against prompt injection and oversharing takes both further.
The Workshop: Run a Retrieval Failure Clinic on Your RAG System
This is a diagnostic clinic, the kind a good garage runs: before anyone orders parts, find out which component is failing.
Who is in the room: the engineer who owns the pipeline and one domain expert from the service desk, throughout. The Lesson 6 data owner joins for tagging and fixes, because several fixes are theirs. Whoever administers identity and access joins for an hour, for steps 3 and 7. The business owner comes for the last 30 minutes.
Time: half a day for the baseline and diagnosis, then two or three short iterations across a week.
Inputs: the Lesson 6 scorecard with its access labels, the scoped sources, the question set, and two test accounts with different access rights.
The eight steps
- Measure the corpus. Count documents and tokens. If the total is under about 200,000 tokens and everyone who will ask may see all of it (the prompt has no permission filter), test the "whole corpus in the prompt" option first, and stop if it passes.
- Build the naive baseline on purpose. Fixed chunks, embeddings only, a small top-K (the number of chunks fetched). You are building the thing you intend to beat. Keep every setting in a configuration file, not in code. The Deakin authors note that chunk size, embedding, retrieval, consolidation and prompts all need calibration.
- Carry the access label onto every chunk, and filter on it. Each chunk inherits its source's Lesson 6 access label and the groups allowed to open it. At question time, the pipeline looks up the asking user's groups and searches only the chunks they may open, before any ranking. Read permissions from the source system on a schedule rather than copying them once, and write down how long a revoked permission can take to reach the index.
- Log everything and mark the ground truth. For each question, log who asked, every retrieved chunk with its source and rank, what was passed to the model, and the answer; the Deakin paper notes that validating a RAG system is only really feasible during operation. Then the domain expert marks which passage holds the right answer, or writes "not in corpus". That retrieval ground truth is the most valuable hour of the week.
- Run the set and tag every wrong answer. One failure point per wrong answer, using the four questions below.
- Fix the largest bucket first, one change per run. Use the working guide below. Adding document context to each chunk (title, section, date, product) is usually one of the runs. Re-run the full set after each change and record retrieval miss rate and answer pass rate. Two changes at once and you will not know which one helped.
- Run the leakage test. Pick a restricted source. Write five questions that only it can answer. Ask them as a test user without access: any answer drawn from that content is a leak. Then ask as a user with access: if those answers fail too, the filter is over-blocking. Repeat after every re-index and every permission change.
- Write it down. The configuration that won, the tally before and after, the leakage result, and the content gaps the pipeline could not fix.
How do you tag a wrong answer?
Open the log for that question and ask four questions in order, stopping at the first "no".
- Was the answer in the corpus? If no: FP1.
- Was the right passage retrieved? If no: FP2.
- Did it reach the model? If no: FP3.
- Did the model use it? If no: FP4. If yes but the answer is still unacceptable, it is FP5 (format), FP6 (specificity) or FP7 (incomplete).
The order matters. It walks the pipeline from the shelves to the memo, so you never blame the writer for a folder that never arrived.
Which fix goes with which failure point?
Use this table as a working guide. It is our synthesis across this lesson's sources, not a finding from any single paper, so expect to adapt it.
| Largest bucket | First things to try |
|---|---|
| FP1 Missing content | Add an "I don't know" path. Report the content gap to the data owner. |
| FP2 Missed top-ranked | Add keyword search alongside embeddings. Add reranking. Add metadata filters. |
| FP3 Not in context | Widen the net and rerank. Tune how results are consolidated. |
| FP4 Not extracted | Remove duplicates and contradictory sources. This is a Lesson 6 data fix. |
| FP5 to FP7 | Prompt and output-format work, covered in Lesson 9. |
| Permission leak (outside the seven) | Filter at retrieval on the asker's rights. Remove restricted text copied into open sources. |
A worked example: the equipment distributor
What follows is invented for illustration. Picture the 900-person industrial equipment distributor from Lesson 6, whose service desk wants an assistant for warranty and parts questions from field technicians.
Step 1. The scoped corpus is about 2,400 documents and roughly 6 million tokens. That is thirty times the 200,000-token threshold, so the briefcase option is out and retrieval is needed. On cost: Anthropic published a one-time cost of $1.02 per million document tokens for adding context to chunks (September 2024, assuming 800-token chunks and 8,000-token documents). On 6 million tokens that is about 6 dollars: an indication, not a quote, but enough to show the steering committee this is not a budget question.
Steps 2 to 4. The engineer builds the naive baseline: fixed chunks, embeddings only, top 5. Most of the warranty set is labelled Internal, but one document, the goodwill-credit limits by customer account, is labelled Sensitive, and shared only with service managers. Every chunk carries its label and the search filters on it. The question set has grown to 120 real technician questions. The service desk expert spends a morning marking the right passage for each. For 9 questions she writes "not in corpus".
Step 5. The baseline answers 80 of 120 acceptably. The team opens the log for each of the 40 wrong answers and tags it.
| Failure point | Count of 40 | What the log showed | Fix chosen |
|---|---|---|---|
| FP1 Missing content | 9 | No document covers the question | "I don't know" path. Gaps sent to the head of service. |
| FP2 Missed top-ranked | 14 | Right passage existed but ranked below the top 5. Many were part-number lookups, which is exact-term blindness. | Add keyword search, rerank, widen top-K. |
| FP3 Not in context | 4 | Retrieved, then cut during consolidation | Pass more chunks after reranking. |
| FP4 Not extracted | 6 | Two policy versions contradicted each other | Retire old versions (Lesson 6 fix). |
| FP5 Wrong format | 2 | Table asked for, prose given | Prompt change (Lesson 9). |
| FP6 Incorrect specificity | 3 | Generic answer to a model-specific question | Product-line metadata filter. |
| FP7 Incomplete | 2 | One of two conditions missing | Prompt change (Lesson 9). |
Look at the top three rows. 27 of the 40 failures (FP1, FP2 and FP3) happened before the right passage ever reached the model. Swapping the model would have fixed none of them. Six more (FP4) happened in generation, but the cause was two contradictory policy versions, and a different model would still have had to guess which was current. The team had already swapped the model twice.
Step 6. One change per run, largest bucket first. Retrieval miss rate here is counted over the 111 questions that have a marked passage.
| Run | The one change | Retrieval miss rate | Wrong answers | Answer pass rate |
|---|---|---|---|---|
| 0 | Naive baseline | 14 of 111 (13%) | 40 | 80 of 120 (67%) |
| 1 | Keyword search added and merged with embeddings | 6 of 111 (5%) | 32 | 88 of 120 (73%) |
| 2 | "I don't know" path | 6 of 111 (5%) | 23 | 97 of 120 (81%) |
| 3 | Reranking: fetch 30, pass 8 | 3 of 111 (3%) | 17 | 103 of 120 (86%) |
| 4 | Context added to chunks, plus product-line filter | 2 of 111 (2%) | 14 | 106 of 120 (88%) |
| 5 | Superseded policy versions retired | 2 of 111 (2%) | 9 | 111 of 120 (92.5%) |
Three things stand out in that invented table. Run 2 did not touch retrieval, yet it turned nine confident fabrications into nine honest refusals, which the team counts as passes. Run 5 was not a pipeline change either: the data owner retired old documents, and five failures vanished. And four of the nine failures left over are format and completeness, which is prompt work for Lesson 9.
Step 7. The access administrator sets up a technician and a service manager test account. The expert writes five questions only the goodwill-credit document answers.
| Test account | Answers revealing restricted content | What it means |
|---|---|---|
| Technician, first run | 1 of 5 | Leak. The filter worked, but a service desk FAQ page labelled Internal held two rows pasted from the Sensitive document. |
| Technician, after the copy was removed | 0 of 5, all five routed to "I don't know" | Pass. |
| Service manager | 5 of 5 answered correctly | The filter is not over-blocking. |
That first leak is the lesson. The pipeline honoured every label, and the label on the source was right. The copy was the problem, and only a low-privilege test account found it. The data owner removed the rows and added "restricted text copied into open pages" to the Lesson 6 checks.
The artifact: your RAG Failure-Point Diagnosis and Pipeline Configuration Sheet
Step 8 produces one page. Copy the left column and fill in the right; the examples come from the distributor illustration.
| Field | Example entry |
|---|---|
| Use case and corpus size | Technician warranty and parts assistant. About 2,400 documents, roughly 6 million tokens. |
| Do we need RAG? Decision and reason | Yes. Corpus is far above the 200,000-token threshold. |
| Chunking method and size | Fixed-size chunks. Size recorded in the configuration file. |
| Context added to chunks | Title, section, date, product line. |
| Search methods and fusion | Keyword and embedding search, rankings merged. |
| Reranking in, out and passed to the model | 30 in, 8 out, all 8 passed. |
| Access control at retrieval | Results filtered by the asking user's permissions, using the Lesson 6 access label; tested with a low-privilege test account. Permissions re-read from the source nightly. |
| Leakage test result | Technician account 0 of 5 after one copied page was removed. Manager account 5 of 5. Re-run after every re-index. |
| The "I don't know" rule | If no retrieved passage supports an answer, say so and route the question to the service desk. |
| Failure-point tally, before and after | Before: 9, 14, 4, 6, 2, 3, 2 (total 40). After: 0, 2, 1, 1, 2, 1, 2 (total 9). |
| Retrieval miss rate and answer pass rate per run | 13% and 67% at baseline. 2% and 92.5% at run 5. |
| Content gaps returned to data owners | 9 questions with no written answer, sent to the head of service. |
| Open issues | Format and completeness failures, for Lesson 9. Misgrounded rate not yet sampled. |
| Date and owner | The clinic date. The pipeline engineer, with the access administrator signing the leakage result. |
In the last 30 minutes, show the business owner three things: the before-and-after tally, the leakage result and the content gaps. The last matters more than it looks: it is the first precise list of questions the business's own documentation cannot answer.
Failure Modes, How to Spot Them, and the Metrics to Track
The clinic itself can go wrong. Watch for these eight patterns, each with a quick test. A security lead will ask about the last two first.
| Failure mode | How to spot it |
|---|---|
| Tuning the generator for a retrieval fault | The model has been changed twice and nobody has opened the retrieval log. |
| No abstention | Ask five questions you know are not in the corpus. A system that answers all five has FP1. |
| Exact-term blindness | Part numbers, codes and names fail while conceptual questions pass. |
| Context stuffing | Adding more chunks stopped helping, or made answers worse. That is context rot. |
| Hard-coded pipeline | Changing the chunk size needs a code release. |
| Trusting the vendor label | "Hallucination-free" appears in the business case with no test behind it. |
| Permission leakage | Log in as a test user without access to restricted sources and ask five questions only those sources answer. Any answer drawn from them is a leak. |
| Access enforced in the prompt | The only thing keeping restricted text out of answers is an instruction to the model, or a filter applied after the answer is written. |
The five-question abstention test takes ten minutes and is the single cheapest check in this lesson. The five-question leakage test takes about as long and is the one most likely to stop a launch.
What if you are buying an assistant rather than building one?
Run the same clinic as your acceptance test. Ask the vendor for the per-question log (retrieved passages, sources and ranks), because without it you cannot tag a single failure. Run the abstention and leakage tests with your own questions and test accounts, not the vendor's demo set. And ask in writing how source permissions reach the index, and how long a revoked permission takes to stop appearing in answers. A vendor who cannot show which passage an answer came from is asking you to trust a label.
Which metrics should you track for a RAG system?
Track six, and record them for every configuration you try.
- Retrieval miss rate. The share of questions whose expert-marked passage is not in the retrieved set. Anthropic's version of this is 1 minus recall at 20.
- Failure-point distribution. The count of wrong answers under each of FP1 to FP7, before and after each change.
- Abstention accuracy. The share of known out-of-corpus questions where the system declines to answer.
- Misgrounded rate. The share of answers whose cited source does not support the statement, checked by the domain expert on a sample. This is Stanford's dangerous category, and no automatic counter will find it for you yet.
- Leakage rate. The share of leakage-test questions answered from content the test account may not open. The target is zero, re-checked after every re-index and permission change.
- Cost and latency per answer. Reranking and longer contexts are not free. Record both next to the quality numbers so the trade is visible.
One honest limit: everything above was judged by hand, by one expert. That suits a first diagnosis and is far too slow to repeat after every setting change. The LLM evaluation lesson on golden test sets turns it into a golden test set and a calibrated judge, so later changes are scored in minutes instead of argued in meetings.
Frequently Asked Questions
What is a RAG system?
A RAG system fetches passages from your own documents and then has a language model answer using those passages. It has two stages, retrieval and generation, and either can fail. RAG stands for retrieval-augmented generation.
Why does naive RAG fail?
Naive retrieval relies on embedding similarity over fixed chunks, so it misses exact terms, loses document context and leaves the right passage outside the top results. The Deakin "Seven Failure Points" paper (January 2024) places three of its seven failure points (missing content, missed top-ranked documents, not in context) before the model ever sees the right passage.
Does RAG eliminate hallucinations?
No. A Stanford study in May 2024 found commercial legal research tools built on retrieval still hallucinated on more than 17% to more than 34% of test queries. Retrieval lowers the rate sharply compared with a general chatbot, but you still have to test on your own questions.
Will a better model fix wrong RAG answers?
Usually not on its own, because many wrong answers start before the model is involved. Tag each failure first: in this lesson's illustrative clinic, 27 of 40 wrong answers came from missing content, missed rankings or passages dropped before generation, and keyword search, reranking and an "I don't know" path fixed most of them.
How do you stop a RAG assistant from leaking restricted documents?
Filter at retrieval, before ranking, so the search only returns passages the asking user may open, using each source's access label. Then prove it: from a test account without access, ask five questions only a restricted source can answer, and treat any answer drawn from that source as a leak.
Key Takeaways
- A RAG system has two stages, find and write. Barnett and colleagues place three of the seven failure points before generation, so check the finding before you touch the writing.
- Retrieval reduces hallucination and does not remove it: Stanford's May 2024 study found retrieval-based legal tools still hallucinated on more than 17% to more than 34% of queries. Treat "hallucination-free" as a red flag.
- Learn the two error words. Incorrect means the statement is wrong. Misgrounded means the citation does not support it, and that one is more dangerous because readers stop checking.
- Tag every wrong answer with one of the seven failure points by asking in order: was it in the corpus, was it retrieved, did it reach the model, did the model use it?
- Fix the largest bucket first, one change at a time: an "I don't know" path, hybrid search, reranking, context on every chunk, and cleaner sources.
- Enforce the Lesson 6 access labels in retrieval, not in the prompt, and prove it with a leakage test from a low-privilege account after every re-index.
- Leave with the RAG Failure-Point Diagnosis and Pipeline Configuration Sheet, and hand the content gaps and any copied restricted text back to the data owners.
Skill.re