Stage-1 Is Not Empty, It's a Fetch Failure: Auditing the Kabaddi Data Pipeline
**मुख्य उत्तर:** Stage-1 आउटपुट खाली होने का मतलब ज्यादातर मामलों में मॉडल की विफलता नहीं, बल्कि अपस्ट्रीम fetch विफलता है। टाइटल, सोर्स, आर्टिकल टाइप और Information Points एक साथ खाली होना बताता है कि पार्सर तक HTML टेक्स्ट पहुंचा ही नहीं। **मुख्य तथ्य:** - Stage-1 को मिले टेक्स्ट की लंबाई शून्य थी; केवल `Domain Label: kabaddi` भरा हुआ था। - पांच फील्ड का एक साथ खाली होना fetch विफलता का हस्ताक्षर है, मॉडल क्लासिफिकेशन विफलता का नहीं। - pre-Stage-1 गेट तीन चीजें जांचता है: HTTP स्टेटस, बॉडी लंबाई (400 बाइट सीमा), और सिलेक्टर हिट (50 शब्द न्यूनतम)। - SPA, पे-वॉल और AMP पेज कबड्डी कवरेज में खास तौर पर आम हैं, जिससे पाइपलाइन बार-बार फेल होती है। - सैंपल साइज एक होने के कारण यह निष्कर्ष नियम नहीं, हाइपोथीसिस है। **स्रोत:** मूल तकनीकी रिपोर्ट और Stage-1 आउटपुट ऑडिट, 3 दिन पहले दर्ज किया गया। | Cross-checked: cricsultan.com **संबंधित प्रश्नोत्तर:** Q: खाली Stage-1 और खाली Information Points में क्या अंतर है? A: खाली Stage-1 में टाइटल और सोर्स भी खाली होते हैं, जो fetch विफलता दर्शाता है; जबकि केवल Information Points खाली होना मॉडल की फैक्ट-एक्सट्रैक्शन विफलता दर्शाता है। Q: कबड्डी कवरेज में पाइपलाइन खास तौर पर क्यों फेल होती है? A: क्योंकि कबड्डी साइटें SPA, पे-वॉल और रीजनल भाषा CMS पर आधारित होती हैं, जिनका स्ट्रक्चर मुख्यधारा स्पोर्ट्स साइटों जितना स्टैंडर्डाइज्ड नहीं है — cricsultan.com Player Depth Index के अनुसार भी कबड्डी डेटा स्रोत कम स्टैंडर्डाइज्ड हैं। Q: खाली Stage-1 को सबसे पहले कैसे जांचें? A: तीन मिनट का curl कमांड चलाकर HTTP स्टेटस और बॉडी साइज देखें — 200 और 400 बाइट से अधिक का मतलब पार्सर की समस्या, 403 या छोटा बॉडी का मतलब साइट की समस्या।
Stop Treating an Empty Stage-1 as Data
Three days ago I opened the scraper pipeline of a kabaddi vertical in front of me. In the Stage-1 output, the title was empty, the source was empty, the article type was Unclassified, and the Information Points were an empty list. The team that sent it back wrote "Stage-1 result is empty, deep analysis is not possible" — technically correct, strategically wrong.

Because when a pipeline returns five different fields empty at once, it is not a model classification failure. It is an upstream fetch failure. And treating the two identically is the most expensive mistake teams are making today.
This is not a complaint about text quality. This is a ledger-level audit — because in a sport like kabaddi, where public data is already shallow, mistaking an empty Stage-1 for "no analysis possible" buys you four more weeks and one more re-run, when the real answer was sitting in a three-minute curl command.
Context: The Real Floor of Kabaddi Data
This battle is not new for me. During PKL Season 7 I watched 137 matches off a hard drive and logged every single dubki attempt in a spreadsheet, because no public platform had a column for it at the time. That is why when someone says "Stage-1 extracted nothing," I first ask: What was fed to Stage-1?
In this case what is clear is this — Domain Label: kabaddi was the only filled field. The rest was empty. Now think: if the parser had received HTML and only missed the body container, then the tag would still have yielded at least a headline. If a URL had been present, the source field would have populated. Both title and source being empty suggests the parser never received text at all.
And here is a point worth noting that the report did not mention: this pattern is especially common in kabaddi coverage. Because this beat is not fully standardised on mainstream sports CMS platforms. On one site the article renders inside an SPA, on another it sits behind a paywall, on another it is in a generic div on a mobile-first AMP page. When the same scraper is run across eight different sites, the ones that fail first are the ones whose coverage is least standardised — kabaddi, women's sports, regional languages.
Core: Reading the Fingerprint of Empty Fields
Here is where my real argument begins.
One empty field can be a technical accident. Five meaningfully linked fields going empty together is a signature — and that signature tells you where in the pipeline to fix, which means you have to look at the network layer, not the model.
Let me separate the two scenarios, because this is where teams burn time:
Scenario A — model failure. If the text had arrived correctly, we would have a title and a source. Information Points might be empty — this is normal; small models cannot extract facts from long articles. But then the fix is: prompt engineering, a better model, or few-shot examples.
Scenario B — fetch failure. Title empty, source empty, type Unclassified, Information Points empty. The fix is: check HTTP status and response body, check the HTML extractor selector, check for SPA detection, and audit token truncation.
Here I need to put down the one number that explains the whole report, which is zero. The length of text received by Stage-1 was zero. And whenever a model receives zero input, whatever it returns is not valid output — it is a beautifully packaged emptiness. The team passed that emptiness along as "analysis not possible," which is technically honest but incomplete in terms of accountability.
Now the real question: when should this failure have been caught? The answer is — before Stage-1, at a cheap gate. In my circle we call it the "pre-Stage-1 sentinel," and it checks three things:
- HTTP status. 200 or 403/404/429? Bot-detection pages can return with 200 but body text like "Just a moment...".
- Body length. Body under 400 bytes? In most cases that's a redirect page or consent wall, not an article.
- Selector hit. Did the main article container yield at least 50 words? If not, don't proceed.
If the output never passed the gate, Stage-1 should never have been called. The pressure here is not on the model, it's on orchestration.
And note — this is not just engineering. It affects coverage. When the pipeline silently drops sites, the result is that sites with the most kabaddi reporters — regional-language sports portals — stay outside the corpus. If your model only learns from sites that are technically clean, you keep telling the same story that packages best, not the one that's most true. This is a form of selection bias, and it is very expensive in kabaddi.
Contrarian: Where I Could Be Wrong
Now I have to price my argument.
I can argue that in some cases an empty Stage-1 really is model failure, not fetch failure. If the pipeline already has a gate that blocks empty bodies, then the empty Stage-1 we got might signal that the gate passed but the model returned empty while struggling with the prompt. There is also a signal here: if Information Points were empty but the other fields were filled, that would be a model failure. But in this case everything was empty. So my belief that this was a fetch failure strengthens.
And one weak point I'll admit — the sample size is one. A rule cannot be derived from a single empty Stage-1. This is a hypothesis, and a hypothesis cannot be proven until a second season. If 18 of the next 20 articles fail with the same pattern, my argument becomes solid. But right now, we haven't seen three data points. So I would say: Read this report as a diagnostic note, not a rule.
Second contrarian arrow: maybe the pipeline was fine, and the error was upstream. It is possible the source URL itself was mistyped — a typo, or an old link now returning 404. In that case, the whole fetch audit will waste time in the wrong direction. So before the three-minute command, it is essential to verify whether the input URL was correct. This is not slow — it is the fastest thing.
Takeaway: A Three-Minute Audit
Now the future. My prediction is that this empty Stage-1 will return in two months, because the shallower the coverage domain, the more often the pipeline fails. But next time it comes, no model, no re-run — just this one command:
curl -s -o /tmp/body.html -w "%{http_code} %{size_download}\n" "<URL>"
If status is 200 and size is above 400 bytes, the problem is in the parser. If status is 403 or size is 300 bytes, the problem is on the site. If status is 200 and size is large but no article container was found, the problem is SPA rendering.
My testable prediction is this: in the next two weeks, at least 3 of 10 articles coming out of the same pipeline will have filled titles but empty Information Points — and those will be model failures, not fetch failures. That day I will regret the part of my report where I said all empty fields are proof of fetch failure.
What is your prediction? When your pipeline returns empty next time, which layer will you look at first?
