Build or buy

The prototype is a weekend, the product is not

Last reviewed Itzal engineering team

Book a demo All articles

A pattern matcher over outbound prompts is genuinely a weekend of work, and it will find card numbers. What takes years is context, the surfaces beyond the browser, enforcement that does not break the tools, and evidence somebody will accept.

What is easy

Finding a card number is not the hard part.

Luhn and a BIN check will validate card numbers reliably in an afternoon. National identifiers, IBANs and key formats are pattern work with known shapes. A competent engineer gets a credible demo quickly, which is exactly why this looks buildable.

The demo is also where most internal builds stop being representative, because real traffic is mostly prose and the prose is where the difficulty lives.

What is hard

Context is what separates a demo from a deployment.

A sixteen-digit number beside the word example is not a card number. A column headed Name holding four hundred entries is a record rather than a mention. Getting those judgements right is the difference between a tool people keep and one they learn to dismiss.

Then there is everything that is not the browser: desktop applications that pin their certificates, file attachments, pasted screenshots, and agents acting on a person's behalf. Each is its own capture problem.

And enforcement has to act inside the time a send already has. A control that freezes the browser gets uninstalled by the person it protects, which is why a deadline and a fail-open path are design requirements rather than nice to have.

The part nobody budgets

Capture breaks quietly when a vendor redesigns a page.

Capture bound to a page's structure stops working when that page changes, and it stops silently: the console simply reports nothing, which is indistinguishable from a quiet week.

Catching that needs tiered selectors, health telemetry per connector, and something that proves capture still fires. It is ongoing work with no visible output when it is going well, which makes it the first thing to lose a maintainer, and the resulting gap is the silent kind.

The second year

The cost that shows up after the first release.

Build estimates are usually honest about the first version and silent about the maintenance, which is where this particular category is unusually expensive. The detectors are the smallest part of it.

Three things change underneath you. Providers ship interface changes that break a composer hook without warning. New tools appear, and an assistant added inside software you already approved is not a new hostname at all, so a surface list needs revisiting rather than extending. And false positives need tuning against your own documents, continuously, because the cost of a noisy rule is that people learn to dismiss the warning.

None of that is a reason not to build. It is a reason to price the second year rather than the first, and to be clear about who owns it when the engineer who wrote it moves teams.

  1. 01

    Composer hooks

    Each surface is its own integration, and interface changes break them silently rather than loudly.

  2. 02

    Surface coverage

    The list of places a prompt can be written grows every quarter, including inside software already approved.

  3. 03

    Detector tuning

    Precision against your own corpus, revisited as the corpus changes. A noisy rule teaches people to ignore it.

  4. 04

    Evidence

    Whatever your auditor wants, in a form they accept, including the months before the control existed.

Who owns it

The maintenance lands on whoever is still there.

Build decisions are made by the engineer who is excited about the problem, and maintained by whoever inherits it. That gap is a bigger factor in how these projects end than any technical consideration.

A detection system is not a project that completes. It needs somebody watching whether capture still works after a provider ships a redesign, tuning rules as the corpus changes, and answering for it in an audit. That is a part-time ongoing commitment rather than a quarter of work, and it is rarely anybody's stated objective once the person who wanted it has moved to another team.

The question worth asking before starting is not whether you can build it. It is who will own it in eighteen months, what else that person will be responsible for, and what happens when the two conflict. If there is no clear answer, the realistic outcome is a system that runs, reports healthy, and quietly stopped catching things some months ago.

When building is the right answer

Build where the thing you are detecting is yours alone.

There is a version of this decision where building wins clearly, and it is worth naming rather than pretending otherwise.

If the sensitive data is specific to your business, an internal identifier format, a product codename, a customer reference scheme, then nobody else's detector knows about it and you will be writing the rules regardless. If you already run endpoint software with a team that owns it, the deployment cost that usually dominates is already paid. And if the requirement is genuinely narrow, one surface, one data class, one team, then the maintenance burden stays small enough to carry.

The hybrid is the common ending: buy the engine and the surface coverage, write your own rules on top of it, because custom rules are the part that needs your knowledge and surface coverage is the part that needs somebody to maintain it every quarter. Any product worth buying lets you do that without professional services.

Questions

Is building ever the right answer?

Yes, where the requirement is genuinely unusual: an internal tool nobody else sees, a data class specific to your business, an air-gapped environment. Those are real, and a bought product may not reach them. For the common case, you are rebuilding something that exists.

What does the first version typically miss?

Context, almost always. The prototype fires on anything that matches a pattern, the false positive rate makes people dismiss warnings, and the tool is quietly switched to log-only within a month. That is the usual arc.

Could we build detection and buy capture?

That is a reasonable split and some organisations do it, usually to keep a proprietary data class in house. It works where the bought product exposes a hook for custom rules. Most do, and it is worth confirming before signing.

How many engineers does a serious build take?

The honest answer is that detection is one engineer and the product is a team. Capture across browsers and desktop apps, enforcement, the console, the evidence trail, and keeping all of it working as vendors change their pages is not a side project.

What about using an open-source detection library?

A sensible starting point for the pattern layer, and it does not address capture, enforcement, context or evidence. You still own the hard four, which is the part that determines whether anyone keeps using it.

How do we decide?

Write down what you would have to maintain forever, not what you would have to build once. The build estimate is usually right and the maintenance estimate is usually missing, and the second one is what decides it.

How long does a working internal version actually take?

A pattern-matching prototype is a weekend. Something you would deploy to a fleet, with contextual detection, more than one surface, a console and a tuning loop, is realistically two engineers for two to three quarters, followed by continuing maintenance that does not end.

What is the most underestimated part of building it?

Surface coverage, by a distance. Each composer is its own integration, providers change their interfaces without notice, and the breakage is silent: the component keeps running and reporting healthy while capturing nothing. Detection is the part people estimate; coverage is the part that recurs.

Can we build on an open-source detection library?

Yes, and it is a reasonable starting point for patterns and some named-entity work. What those libraries do not give you is composer integration, a redaction guarantee that holds through logging, or anybody to maintain the surface list when a vendor ships a redesign. Those are the recurring costs.

Keep reading

See what the built version has to match.

Capture across browsers and desktop apps, context, enforcement in the send, and the evidence trail.