Stage-1 Came Back Empty: The 'Valid-Looking Empty Record' Problem in a Kabaddi Content Pipeline

1. One-line status

Stage-1 output is completely empty — only the field Domain Label: kabaddi is populated — so no factual sports news report can be written from this input. What follows is an analysis of the failure that made the report impossible.

1. What the input actually contained

| Field | Status | |---|---| | Article Title / Source / Type | N/A / N/A / Unclassified | | One-sentence Summary | Empty | | Author Stance / Purpose | N/A | | Information Points | Empty list | | Entities / Time Sensitivity / Source Quality | Not assessed |

The total available signal is one word: kabaddi. That tells us only that the upstream system considered the material related to kabaddi. Nothing beyond that.

One distinction must be kept clean: "there was little information" and "no information arrived at all" are different states. The first limits analysis; the second makes it impossible. This is the second.

1. Why deep analysis is impossible — four pillars and their preconditions

Argument decomposition: what is the article's central claim, what supports it, what was omitted. With no claim there is nothing to decompose.

Evidence-chain assessment: which figure came from which source, whether it is primary or secondary, a direct quote or a paraphrase. No sentences means no evidence; no evidence means no chain.

Stance and purpose detection: whether the author is informing, defending, accusing or entertaining is determined by word choice, the intensity of adjectives, and who gets quoted. With no language, there is no stance to extract.

Time sensitivity: whether a claim holds today or is six months stale depends on dates and event order. Dates are absent.

What remains without these four is inference, and calling inference news is wrong. That is why no score, no quote, no player name and no date has been invented here.

1. Four candidate failure points

(a) Upstream fetch failure. The input body was empty, or contained only navigation and template text. Symptom: very low character count in the raw snapshot, or HTML with only header, footer and menu. Verification: re-fetch the URL and inspect status code, content-length and content-type.

(b) The body extractor classified the entire article as boilerplate. This is common on JS-rendered pages, behind paywalls, and with PDFs. Symptom: the article exists in the HTML but extracted text is zero or negligible. Verification: run the boilerplate remover on the same page with a different config, and render it through a headless browser.

(c) The classifier ran, the extraction stage crashed, and the fallback wrote empty values. This is the most likely reading, because the domain label is populated while everything else is empty. Symptom: an exception or timeout against the same request-id in the logs. Verification: pull the trace for that run and check timing and errors at stage boundaries.

(d) Schema conversion dropped fields. The LLM returned invalid JSON and the validator silently wrote defaults. Symptom: the raw LLM response is available and contains content, while the parsed object is empty. Verification: preserve the raw response and re-parse it.

The only reliable way to distinguish these four is to persist raw input and raw output at every stage.

1. Why a valid-looking empty record is the most dangerous output

A loud error — an exception, a 500, a null — stops the system. An empty but schema-valid record stops nothing. It enters the database, propagates downstream, and looks normal there. No alert fires, no dashboard turns red, and after a while you hold thousands of records where it is impossible to tell which were genuinely empty and which were partially filled.

This is the most expensive form of failure, because it spreads silently and later surfaces as a vague "data quality" problem — when a single assertion could have caught the root cause.

1. Proposed contract

Stage-1 output should carry an explicit assertion:

information_points.length > 0 AND summary!= ""

On failure, mark the record status = extraction_failed, persist a raw_input_snapshot, and do not forward it downstream. Make record_status an enum — ok, partial, extraction_failed — so that "empty" and "incomplete" are both visible rather than collapsing into "nothing".

1. Observability that catches a recurrence immediately

Carry these per record: schema_version, extractor_version, fetch_status, content_length, parse_path, and per-stage duration. Alert on the rate of empty outputs. Track failure rate by domain to distinguish a systemic problem from a few problematic sites. Most importantly, store a raw input snapshot with every failure; without it, root-cause analysis later is impossible.

1. Correct downstream behaviour (this writing stage)

Fail closed. Do not write an article from empty input; record extraction_failed and request a re-fetch. A system that produces "something" even from empty input makes its own failure invisible — and then an upstream fault hides behind a downstream one.

1. What this report does not contain, and why

No match result, no score, no player name, no quote, no date, no tournament detail. The reason is simple: none of these elements were in the input. In sports journalism a fabricated quote or a wrong score is not merely an error; it is permanent damage to trust.

1. What is needed to write the real report

In priority order: (a) the source body text — this enables full analysis; (b) the raw Stage-1 JSON or run logs — this establishes whether the failure was in extraction or in the schema; (c) if the body is unavailable, only verifiable metadata: title, publisher, publication date, URL — this allows source-quality and time-sensitivity assessment, with everything else explicitly flagged as out of scope.

1. Background — general knowledge, not news

This section is for reader context and is not tied to any specific event, match or person. Kabaddi is a contact sport with two teams and seven players per side on the mat. A raider crosses into the opposing half, must keep chanting "kabaddi" on a single breath, tags defenders and returns. A successful tag sends an opposing player out and revives one player of the raiding side; if the raider is held, the raider is out. Rule details vary by version, so the rules of any specific competition should be checked against its official rulebook. A professional league began in India in 2026, and kabaddi has long featured in the Asian Games programme. Treat these as background — they are not facts derived from this input.

1. Conclusion

The root problem in one sentence: the pipeline wrote "nothing was found" as "empty but valid". Fixing it needs no large refactor — one assertion, one status field, one raw snapshot and one alert. Until then, every downstream stage faces the same dilemma: either fabricate content on empty data, or stop. Stopping is correct, but it only works if upstream says clearly, the first time, that it failed.