Digital Engineering/AI Product Assurance

Turn AI-built software into a production-ready product

Your product works, but working isn't production-ready. Noseberry assesses AI-built software across six engineering dimensions, shows you exactly what stands between the version you have and the version you can operate, and fixes it if you want us to.

Assessed against OWASP ASVS & NIST SSDFRead-only access, NDA-firstFindings you own, evidence you can act on

What is AI product assurance?

AI product assurance is the process of assessing software built with AI coding tools across six engineering dimensions: code health, application security, product architecture, scalability, cloud and delivery, and engineering governance, then remediating what is found, so the product is reliable enough to operate and sell.

The gap AI leaves between building and operating.

01

The code works but nobody knows why.

Generated code is locally correct and globally incoherent. Three modules solve the same problem three different ways because each was generated in a separate session with no memory of the others. It runs fine. It is very hard to change.

02

Security was assumed, not designed.

An authorisation check appears in four routes and quietly does not appear in the fifth, because the fifth was added a fortnight later in a different conversation. Secrets end up committed. Input validation exists where it was asked for and nowhere else.

03

The data model was built for the demo.

It holds for a hundred records and buckles at a hundred thousand. Queries with no index. Relationships that made sense for one tenant and make no sense for twenty.

04

Nothing was written down.

No architecture decisions, no test suite worth running, no deployment process beyond one person and one terminal. When that person is unavailable, the product is frozen.

05

The first enterprise customer asks questions nobody can answer.

Where does customer data live, who can reach it, how do you roll back a bad release, what happens if a dependency has a critical vulnerability. Ordinary questions with no answers in the codebase.

None of this is a failure of the tools. It is the ordinary gap between building software and operating it, the gap engineering teams normally close over months of unglamorous work. AI compressed the build. It did not compress that.

Find the right service

Noseberry answers your question with the right service. Most engagements start with one and expand once the findings are on the table.

01

AI Code Audit

The diagnostic. We read the codebase and tell you what is actually in there, structure, quality, security exposure, test coverage, dependency risk, and how much needs to change. Fixed-scope entry engagement. Start here if you do not yet know how bad it is.

02

Vibe Code Cleanup

The remediation. You know the software has problems and you want them gone. We apply a Retain / Refactor / Replace decision to every component, then execute it, with the product staying live throughout.

03

AI Application Security Audit

Focused security assessment for a customer security review, a procurement questionnaire, or a genuine incident. Assessed against OWASP ASVS and the OWASP Top 10, with secure-SDLC practice referenced to NIST SSDF.

04

Architecture & Scalability Review

For products that work now and will not work at ten times the load. Data model, service boundaries, state management, caching, query behaviour, and the specific point at which your current design stops holding.

05

Production Readiness & Hardening

Everything between “it runs on my machine” and “it runs reliably without me”, deployment pipeline, environments, monitoring, alerting, backup and restore, incident response, and the operational documentation an on-call engineer needs at 3am.

06

Software Technical Due Diligence

For investors and acquirers assessing an AI-built asset before a cheque clears, and for founders who want to know what diligence will find before diligence finds it.

07

AI Development Governance

The forward-looking one. This sets how your team uses AI tooling from now on, approved tools, generation standards, agent stop conditions, review discipline and the accountability model, so the same findings do not come back next year.

08

AI-Assisted Product Development

The build service, for anyone who has not built the product yet or has a prototype that needs to become one. Agent-driven speed with the engineering underneath it, assessed against the same six dimensions at delivery.

09

Continuous Product Assurance

Per-release sign-off and scheduled re-assessment on subscription, so the audit stops being an event and the picture stays current as you keep shipping. Currently running with a limited number of teams.

Not sure which one?

Send us the repository and a paragraph about what is worrying you. We will tell you which assessment answers your question, including when the answer is that you do not need one yet.

Ask us which one

The Noseberry Product Assurance Framework

Every engagement is assessed against the same six dimensions, whether we built the software or another team did. Each dimension is evidenced, not asserted. The methodology, including what evidence supports each assessment, is published in full.

Read the assessment methodology
01

Code Health

Structural coherence, duplication, complexity, naming and boundary discipline, test coverage and quality, and how much a new engineer could safely change in their first fortnight.

02

Application Security

Authentication and authorisation models, input handling, secrets management, dependency and licence provenance, data exposure paths, and whether a control that exists is applied consistently.

03

Product Architecture

Data model integrity, service and module boundaries, state and ownership of records, integration design, and whether the structure matches the product now rather than the first prototype.

04

Scalability & Performance

Query behaviour under realistic data volume, caching, connection and concurrency handling, background work, and the specific load at which the current design stops holding.

05

Cloud & Delivery

Environments, infrastructure definition, deployment and rollback, secrets and configuration handling, observability, and cost behaviour as usage grows.

06

Engineering Governance

How change is proposed, reviewed, tested and released; where AI tooling sits in that process; what is documented; and what happens when the person who built it is unavailable.

CriticalNeeds AttentionReady

Each dimension receives one of these three statuses, and every finding underneath it carries a class and a plain statement of business impact. A dimension marked Critical is not an opinion about code taste. It means we found something that will cost you money, customers or time in a way we can point at.

Numeric scoring is held until the methodology page is published in full. We would rather ship a defensible status than an impressive-looking number nobody can check.

Who this is for

Founders who built it themselves.

You shipped a real product without an engineering team, you have customers, and every change now breaks something else. You are not looking for someone to tell you the tools were a mistake. You want to know what to fix first.

Product and operations leads inheriting AI-built software.

Someone built it, that person has moved on or moved up, and it is now your problem. You need an honest inventory before you can plan anything, in language you can take to a board.

Engineering leaders whose teams have been using AI heavily.

Velocity is up and confidence is down. You suspect the codebase has drifted in ways your review process is not catching, and you want an outside read before it calcifies.

Teams facing an enterprise buyer or a security review.

A customer has sent a security questionnaire, a penetration test is scheduled, or procurement wants evidence of engineering practice. You need to know what will be found before someone else finds it.

Investors and acquirers.

The asset was built with AI, the team is small, and the standard diligence checklist does not ask the questions that matter here.

The moments people usually call us

The call almost never comes because someone woke up curious about code quality. It comes because something specific happened.

01

Something broke in front of customers, twice.

The first outage was bad luck. The second one, in a different part of the system, means the first one was not bad luck.

02

A change that should have taken an hour took four days.

Every fix reveals two more. The codebase has started to resist you, and the resistance is getting worse rather than better.

03

An enterprise prospect sent a security questionnaire.

Forty questions, and the honest answer to most of them is “I don’t know”. The deal is real and the questionnaire is now the critical path.

04

You are about to hire your first engineers.

You would like to know what you are handing them, and you would prefer to hear it from someone who is not being interviewed.

05

A fundraise or an acquisition is coming.

Technical diligence will happen. You would rather run it on yourself first, while there is still time to fix what it finds.

06

Costs went up and nobody can explain why.

The cloud bill grew faster than usage, which usually means something is doing far more work than it needs to.

07

A dependency was flagged and nobody knew it was in there.

No inventory, no provenance, no way to answer “where else is this used” without reading everything.

08

You are considering a rebuild.

Someone has suggested starting again. That is sometimes right and usually expensive, and it should be a decision made against evidence rather than frustration.

How an assessment runs

01

Scope and access

day 0

A 45-minute call covering what the product does, who uses it, what has already gone wrong, and what decision the assessment needs to support. NDA executed before anything is shared. We agree which repositories and environments are in scope and which are explicitly out.

02

Automated pass

days 1–2

Static analysis, dependency and licence scanning, secrets detection, complexity and duplication measurement, infrastructure configuration review. Tuned to your stack rather than run at defaults, because default rulesets on an unfamiliar codebase bury the two findings that matter.

03

Engineering review

days 2–6

Engineers read the system. This is where the findings that change decisions come from: whether the authorisation model is coherent, whether the data model survives your second enterprise customer, whether the thing your team calls a service is three responsibilities sharing a deployment. Tools cannot do this part.

04

Classification and impact

days 6–8

Every finding is classified Critical, High, Medium or Optimisation, with a written statement of what it costs you if left alone and an estimate of the effort to resolve it. Findings are grouped by dimension so the six statuses trace to specific evidence.

05

Report and walkthrough

days 8–10

A written report, a prioritised remediation plan sequenced so the highest-risk items land first, and a live walkthrough with whoever needs to understand it, including a version aimed at non-engineers if the decision sits with a board or an investor.

Typical elapsed time is two weeks for a single-product codebase. Larger or multi-repository systems are scoped individually. You get the findings register as it develops rather than a silent fortnight followed by a document, if we find something Critical on day three, you hear about it on day three.

What you receive

  • A written assessment report covering all six framework dimensions, with a status for each and the evidence that produced it, written to be read by an engineer and understood by a board.
  • A findings register listing every issue found, each one classified Critical, High, Medium or Optimisation, with location, business impact and estimated remediation effort attached.
  • A prioritised remediation plan sequenced by risk and dependency rather than by convenience, so the first two weeks of work remove the most exposure.
  • An architecture and data model review describing the system as it actually is, which is frequently the first time anyone has written that down.
  • A dependency and licence inventory covering what is in the product, where it came from, what is known to be vulnerable, and what carries a licence obligation somebody should know about.
  • A production readiness checklist marked against your current state, so the gap between where you are and operable is explicit rather than implied.
  • A recorded walkthrough of the findings, so people who were not on the call, a new hire, an investor, a technical adviser, can get the full picture without a second meeting.

How findings are classified

A status tells you where a dimension stands. A classification tells you what to do about a specific finding on Monday morning.

Critical

Active exposure, data, money, availability or legal obligation is at risk right now.

Fix before the next release. Days, not sprints.

High

Will cause material damage under conditions you should expect within months, growth, a new customer tier, a departure.

Scheduled into the current quarter.

Medium

Real cost, mostly paid in engineering time and slower change. Compounds quietly.

Planned work, sequenced around delivery.

Optimisation

Improvement with a clear benefit and no urgency.

Do it when the surrounding code is open anyway.

Every finding carries a business-impact line in plain language, because "cyclomatic complexity of 41 in the billing module" is not a sentence anyone can make a decision from, and "one person understands how invoices are calculated and there is no test proving it works" is.

The standards we assess against

Security findings are assessed against established application-security and secure-SDLC standards. Where a product is heading towards a formal certification, we map findings to the control areas it will examine, so remediation work counts twice.

OWASP ASVS

Application Security Verification Standard

OWASP Top 10

The most critical web application risks

NIST SSDF

Secure Software Development Framework

SOC 2

Control areas mapped for readiness

ISO 27001

Control areas mapped for readiness

To be precise

We identify gaps relevant to these standards and describe what closing them would involve. We are not a certification body and this is not an audit in the accounting sense. We do not certify compliance, and any supplier telling you an engineering review makes you compliant is selling you something that does not exist.

What the assessment does give you is evidence, specific, located, classified, that a certification process, an enterprise security review or an investor's technical adviser will accept as a serious starting position.

How we work with your source code

Handing your entire product to people you met last week is a reasonable thing to be uncomfortable about. Here is exactly what happens.

What we need

Read-only repository access, or a supplied archive where your policy requires it. For infrastructure review, read-only cloud console access scoped to the relevant environments. We do not require write access at any point during an assessment. If a remediation engagement follows, write access is granted separately, to named engineers, against agreed branches.

What we don't need

Production database access, customer data, or credentials to live systems. Where an assessment touches data handling, we review schema, classification and flow, not records. If an engineer on our side asks for production data, that is a mistake and you should refuse it.

Before anything is shared

An NDA is executed before scoping, not after. Access is granted to named reviewers only, listed by name in the engagement note, and revoked on delivery. If your organisation requires its own agreement rather than ours, we sign yours.

Where the work happens

On our infrastructure by default, on yours where your policy requires it. Static analysis can be run inside your own environment with only the findings exported, if your security team prefers that arrangement, several of our clients' customers require exactly this, and it is a normal request rather than an obstacle.

What we retain

The findings register and the deliverables, because you will want them again and so will your next investor. Source code is deleted on completion unless a remediation engagement follows. Retention periods and deletion evidence are written into the engagement note rather than left to trust.

What automated tools can and cannot find

Static analysis and dependency scanners are part of every assessment we run. If you have never run one, run one today, it costs very little and finds real problems. But a scan is only half the work.

What a scanner finds

  • Known vulnerability patterns
  • Outdated and vulnerable packages
  • Secrets committed to the codebase
  • Obvious complexity signals

What only an engineer finds

  • Whether your authorisation model is actually coherent
  • A permission check present in four routes and silently dropped from the fifth
  • A data model that will not survive your second enterprise customer
  • Two modules that disagree about who owns a record
  • A "service" that is really three responsibilities sharing a deployment
  • Retry logic that can double-charge under a specific failure sequence
  • A fast-growing table with no archival strategy, months before it bites

What changes afterwards

You can answer the security questionnaire.

Not with reassurance, with a document, a findings register, and a remediation plan with dates on it. Enterprise buyers do not expect a small team to be perfect. They expect it to know where it stands, and most can tell the difference within one meeting.

Change stops being frightening.

The most common report we get back, six weeks after a cleanup, is that shipping stopped feeling like a coin flip. That is not a soft outcome. It shows up directly in how much you can build per month.

Hiring gets easier and onboarding gets shorter.

Good engineers interview your codebase as much as you interview them. A real architecture document and an honest findings register is a stronger signal than any pitch about culture.

Diligence stops being a threat.

When technical due diligence arrives, you already know what it will find, because you found it first and fixed the parts that mattered. Deals slow down over surprises, not over problems.

The cloud bill starts making sense.

Performance and architecture findings usually pay for a meaningful slice of the engagement, because the design flaws that make systems fragile are frequently the same ones making them expensive.

You know what you own.

Which is, more often than anyone admits, the thing that was actually missing.

Why Noseberry

We do it the other way round: engineers who build AI software, assessing AI software, against a method we publish in full. Every reviewer has shipped and operated production systems, so the findings are things you can act on rather than technically correct and operationally useless. Every status traces to specific evidence you can argue with, and one framework runs across audit, cleanup, security, architecture and readiness, so you never restart your understanding of your own product. And when a scoping call shows the codebase is in better shape than you feared, we tell you so, even when it costs us the sale.

Evidence

We are early in publishing case evidence for this service line. We will show you anonymised findings registers from comparable engagements on a call, and we will introduce you to a reference client before you commit.

Frequently asked questions

It can be, and a great deal of it already is. The risk is not that a model writes bad code, modern models write reasonable code most of the time. The risk is that nobody applied a consistent security or architectural standard across sessions, so controls appear in some places and not others, and no single person holds the whole picture. Production safety comes from consistency, verification and operational readiness. Those are engineering practices, not properties of the generator, and they can be added to software that already exists.

Our fixed-scope AI Code Audit starts from a published entry price for a single-product codebase, shown on the AI Code Audit page. That covers the automated pass, engineering review, classified findings register, prioritised remediation plan and a walkthrough. Larger systems, multi-repository estates, and engagements needing regulatory mapping are quoted individually after a scoping call. Remediation, security, architecture and readiness engagements are quoted against scope, because their effort varies by an order of magnitude depending on what the audit finds.

Usually fix it, but not always, and the decision should be made against evidence rather than frustration. A rebuild throws away working business logic and every undocumented lesson embedded in it, and it typically takes two to three times longer than estimated. It is genuinely the right call when the data model is fundamentally wrong for the product you now sell, or when the framework choice blocks something you have already promised customers. We apply a Retain / Refactor / Replace decision component by component, so the answer is rarely all of one thing.

Two weeks end to end for a typical single-product codebase, scoping on day zero, automated pass in the first two days, engineering review across the middle, classification and reporting in the final days. Larger or multi-repository systems are scoped individually and usually run three to four weeks. You do not wait until the end to hear anything: the findings register is shared as it develops, and anything Critical reaches you the day we find it rather than in a report a week later.

No. We need read-only repository access and, for infrastructure review, read-only cloud console access scoped to the relevant environments. We do not need production database access, customer data or credentials to live systems. Where an assessment touches data handling we review schema, classification and flow rather than records. An NDA is executed before scoping, access is granted to named reviewers only, and it is revoked on delivery. Where your policy requires it, analysis runs inside your own environment with only findings exported.

You should, and it will find real problems, outdated packages, committed secrets, known vulnerability patterns. Scanners are part of every assessment we run. What they cannot do is judge whether your authorisation model is coherent, whether your data model survives your next customer tier, or whether two modules disagree about who owns a record. Those findings require an engineer who understands what the system was supposed to do. The scan is the cheap half of the work, and it is the half that finds the less expensive problems.

Never without your instruction. The findings are yours. Many clients choose to share the report, a classified findings register with a dated remediation plan is a strong signal to an enterprise buyer or an investor, precisely because it shows the team knows where it stands. If you want a version written for that audience we will produce one. What we will not do is share anything with anyone, in any form, without your explicit written direction.

Then you get a short report saying so, and you spend the money on building instead. This happens more often than founders expect, particularly with products built carefully in a single framework by someone with prior engineering exposure. We would rather deliver that result and keep the relationship than manufacture concern. If a scoping call suggests the assessment is unlikely to earn its cost, we will say so before you commit rather than after.

Both, and they are separate purchases on purpose. The audit is a diagnosis and is deliberately available without any obligation to buy remediation from us, plenty of clients take the findings register to their own team or another supplier, which is a legitimate outcome. Where you do want us to execute, the Vibe Code Cleanup and Production Readiness & Hardening engagements pick up directly from the findings register, with the product staying live throughout.

Enterprise readiness is less about being flawless and more about being able to evidence your position. The practical test is whether you can answer, with documents rather than assurances: who can reach customer data and how is that enforced, how do you know a release did not break a control, what is your rollback path, and what happens when a dependency is disclosed as vulnerable. The AI Application Security Audit exists to produce exactly that evidence, mapped to the questions procurement teams actually ask.

Find out what you actually own

Send us a repository and a paragraph about what is worrying you. We will come back within two working days with a scope, a price and an honest view of whether an assessment is the right spend right now.

Step 1 · Pick a date

Book a 30-min demo

30 minutes UTC
August 2026
SMTWTFS

Mon-Fri, 10:00-23:30 IST. Past dates and weekends are unavailable.