Techbanq

AI · data readiness

AI projects are decided in the data work nobody demos

The model in a failed AI project is usually fine; the corpus behind it is not. Duplicated policies with different dates, scanned documents no system can read, permissions lost on the way into the index — these decide answer quality before a single prompt is written. We do that work first, deliberately.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Market
Saudi Arabia
Written for
CTO, CIO
Decision
Get the organisation's content into a shape an AI system can answer from safely
Languages
EN · AR

Enterprise delivery credentials

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

The pipeline

The five preparation stages between raw shares and a trustworthy index

Each stage exists because skipping it produces a specific, recognisable failure in the answers. The order matters: labelling before deduplication labels the same document three times.

STAGE 01

Normalise the formats

The corpus arrives as PDFs, scans, spreadsheets, emails and wiki pages. Everything is converted to clean, extractable text — with scanned and image-based documents routed through recognition — so no knowledge is invisible to the system simply because of its container. One readable representation per document.

STAGE 02

Deduplicate and pick the authority

Enterprises hold the same policy in four versions across three shares. We detect near-duplicates, and with your owners decide which version is authoritative — because an index holding all four will answer from a random one. One authoritative version per fact.

STAGE 03

Label what retrieval will need

Documents are tagged with the fields answers will be filtered by — department, product, date, language, audience — using a labelling strategy that mixes rules, model-assisted suggestions and human review where the label carries risk. Metadata that lets answers be scoped, filtered and dated.

STAGE 04

Chunk for the questions, not the file

Retrieval fetches passages, so how documents are split decides what the model sees. Chunk boundaries follow the content's own structure — clauses, sections, table rows — and each chunk keeps enough context to stand alone, in Arabic as carefully as in English. Passages a model can answer from without guessing.

STAGE 05

Carry the permissions in

Every chunk keeps the access rights of its source document, enforced at query time, so the assistant never becomes a way to read what a person's role does not permit — the failure that turns a helpful pilot into a security incident. An index that answers within each user's rights.

Why it decides the project

The confident wrong answer traces back to unprepared data

When an AI assistant quotes last year's leave policy with complete confidence, the model has not malfunctioned; it faithfully answered from the copy it was given. Somewhere in the corpus the superseded version survived, undated and unlabelled, and retrieval found it first. The most common failures of enterprise AI — stale answers, contradictions between sessions, missing knowledge that definitely exists in some folder — are corpus defects wearing a model's voice, which is why fixing them at the model layer never works.

This is also where personal data compliance is really enforced. Under the Saudi Personal Data Protection Law, what personal data enters an index, on what basis, and how it is minimised, retained and deleted are questions that must be answered at preparation time — because once personal data is embedded and indexed, removing it is far harder than not ingesting it. We identify personal data before ingestion, exclude or minimise what the purpose does not require, and keep the mapping that lets a deletion request reach the index, so the assistant does not quietly become an unregistered copy of your customer records.

The quality gates

What a prepared corpus must satisfy before an AI system answers from it

These are the checks we run before an index is allowed to serve answers. Each protects against a failure that would otherwise surface in front of a user.

Every source readable and attributed

A chunk that cannot be traced to its document cannot be cited, corrected or deleted.

What it prevents: Answers with no source behind them.

One authoritative version per document

Duplicates with different dates make the answer depend on which copy retrieval happened to fetch.

What it prevents: Contradictory answers to the same question.

Permissions resolved at query time

Access decided at ingestion goes stale the day a person changes role; the check must run when the question is asked.

What it prevents: The index leaking what the source system protects.

Personal data accounted for

PDPL obligations — basis, minimisation, deletion — must be answerable for the index exactly as for the source.

What it prevents: An assistant that is an unmanaged copy of regulated data.

Our role

What we prepare and what your owners decide

  1. 01

    The audit that sets the plan

    We survey the corpus as it actually is — formats, duplicates, languages, permission models, personal data — and return a plan scoped by what we found rather than a generic pipeline.

  2. 02

    The pipeline, built to keep running

    Preparation is not a one-off cleanse: we build the ingestion pipeline that normalises, labels, chunks and permission-scopes new and changed content continuously, so the index tracks the organisation instead of its past.

  3. 03

    Evidence for the compliance owner

    The pipeline documents what entered the index, from where, under what basis and with what handling of personal data, so the data protection officer reviews a record rather than reconstructing one.

Which version of a policy is authoritative, and which personal data the purpose truly requires, are judgements only your owners can make; we surface each decision with its evidence and build the pipeline that enforces what they choose.

Common questions

What buyers ask

How much of an AI project is really data preparation?+

More than any demo suggests, and we deliberately will not put a universal number on it — the share depends entirely on the state of your corpus, which is why the engagement starts with an audit rather than an estimate. A team with a governed document platform and consistent metadata has a short preparation phase; one with fifteen years of shared drives, scanned contracts and duplicated policies has a long one. What is constant is the order: preparation before the AI build, because building the assistant first and discovering the corpus problems through its wrong answers is the expensive sequence.

How does PDPL change what we can feed into an AI index?+

It makes ingestion a processing decision, not a technical convenience. Building an index over content that contains personal data is itself processing under the law, so the questions you answer for any system — what data, what purpose, what basis, how long, how deleted — must be answered for the index too. Practically that means identifying personal data before it is embedded, excluding what the assistant's purpose does not require, and keeping the source-to-chunk mapping that lets a deletion or correction reach the index. Retrofitting those answers after launch means re-processing the corpus; designing them in costs a fraction of that.

What does chunking actually change about answer quality?+

It decides what the model is shown, which is most of what the model can get right. Retrieval does not hand the model whole documents; it fetches the passages that match the question, and those passages are the chunks you created. Split a contract mid-clause and the model sees half an obligation; split a table from its header and the numbers lose their meaning; make chunks too large and the relevant sentence drowns in noise. Good chunking follows the document's own structure and keeps each passage self-explanatory — and in Arabic and bilingual corpora it must respect the language's structure too, which is a place generic pipelines quietly fail.

Next step

Assess your corpus with us

A corpus audit that names what is duplicated, unreadable, unlabelled or over-exposed, and the preparation plan that fixes it before the AI build starts.