When Security Becomes an Afterthought

I’ve watched this story play out dozens of times. A team builds something impressive in a notebook. It works. Everyone’s excited. Then someone asks: who can access this? What happens if it breaks? Can we prove what it did? And suddenly the whole thing grinds to a halt.

The problem isn’t that people don’t care about security and governance. They do. The problem is that these things get bolted on at the end, after the model is trained, after the system is deployed, after the first customer is already using it. By then, it’s too late to design them in.

I’ve seen vector databases where nobody could explain how documents got into them. I’ve seen retrieval systems where the source data was weeks out of date. I’ve seen systems where the same question returned different answers depending on which server handled the request. And I’ve seen access control so complicated that teams needed five approvals and three weeks just to give someone permission to read a log file.

This isn’t a technology problem. It’s a design problem.

The Real Cost of Getting This Wrong

Let me be specific about what I mean. I’ve seen teams where anyone with database access could retrain the model, which meant that a data analyst could accidentally (or intentionally) change the model’s behaviour without anyone knowing. I’ve seen other teams where only one person could deploy models, which meant that a single person leaving the company could paralyse the entire operation. I’ve seen teams paralysed by the complexity of access control itself, where every change requires five approvals and takes three weeks.

Each of these is a real problem. Each one costs money. Each one puts your business at risk.

But here’s what I’ve also seen: when teams get this right, it doesn’t slow them down. It speeds them up. Because when everyone knows who can do what, and why, and what happened when they did it, the whole system becomes predictable. Deployments get faster. Debugging gets easier. Compliance audits stop being a nightmare.

Start with Your Business Outcome

Here’s what I see when teams get this right: they start with their business outcome. Not the technology. Not the model metrics. The actual business problem they’re trying to solve.

Then they work backwards. What data do we need? Where does it come from? Who needs access to it? What happens if it’s wrong? What happens if someone changes it? What happens if the system goes down?

These are the questions that should drive your architecture. Not the other way around.

I’ve seen teams with perfect model metrics and terrible business outcomes because they were optimizing for the wrong thing. I’ve seen teams where the hallucinations were subtle and domain-specific, and the only thing that actually caught them was a human reviewing the output. I’ve seen teams where this is the only thing that actually works, because the problem domain is too complex for automated tests.

So your governance system needs to support this reality. It needs to make it easy to log what the system said. It needs to make it easy to trace where the data came from. It needs to make it easy to see who changed what and when. And it needs to do all of this without slowing down the people who are actually trying to solve the problem.

Access Control That Actually Works

In my experience, teams usually end up with a tiered approach, and it’s the right one.

At the bottom tier, you have read-only access. Someone needs to look at logs, check metrics, see what the system is doing. That should be easy. That should require almost no approval process.

At the middle tier, you have operational access. Someone needs to restart a service, adjust a threshold, roll back a deployment. That should require approval from someone who understands what they’re approving. But it shouldn’t require a committee.

At the top tier, you have change access. Someone is modifying the model, changing the data pipeline, altering the retrieval logic. That should require approval from multiple people, and it should generate an audit trail that your board can see.

The key is that each tier should be easy to understand and easy to implement. I’ve seen teams paralysed by the complexity of access control itself, where the system is so complicated that nobody wants to use it, so they just give everyone full access and hope for the best.

That’s not security. That’s security theatre.

Audit Trails That Tell the Real Story

Here’s where I’ve seen the most creative chaos: the audit trail.

Many teams think an audit trail means logging every API call. That’s not wrong, but it’s not enough. Because you also need to know: why was this call made? Who asked for it? What was the business reason? What was the outcome?

I’ve seen teams with sophisticated monitoring systems where nobody actually knows what the alerts mean. I’ve seen audit logs that are so detailed that they’re useless. I’ve seen systems where the audit trail is so sparse that you can’t figure out what happened when something goes wrong.

The audit trail needs to tell a story. It needs to answer the questions that your board, your regulators, and your customers will ask. It needs to be human-readable, not just machine-readable. And it needs to be built into the system from the start, not added on afterwards.

We can audit what you have, identify the gaps between what you’re doing and what compliance actually requires, and build a roadmap to close them. Because I’ve seen the patterns play out. We’ve seen this enough times to know what questions to ask and where the problems usually hide.

Data Governance in RAG Systems

This is where I’ve seen the most creative chaos. Retrieval-augmented generation (RAG) systems are powerful, but they’re also dangerous if you don’t think about data governance.

I’ve seen vector databases deployed without any thought to data freshness, permissions, or accuracy. I’ve seen retrieval systems where the documents were weeks out of date, and nobody noticed until a customer asked why the system was giving them outdated information. I’ve seen systems where nobody could trace where the data came from, or who had permission to change it, or when it was last updated.

Fix your retrieval layer first. Because if your retrieval layer is broken, your whole system is broken. It doesn’t matter how good your model is if the data you’re giving it is wrong.

Here’s what I’ve seen work: start with your data sources. Know exactly where they come from. Know how often they change. Know who owns them. Know what permissions are required to access them. Then build your retrieval system around that reality. Make it easy to see what data is in your system. Make it easy to update it. Make it easy to audit it.

And make it easy to prove that the data is current and accurate. Because that’s what your customers will ask for. That’s what your regulators will ask for.

Monitoring That Matters

I’ve seen teams where this is the only thing that actually works, because the hallucinations are subtle and domain-specific. You can’t catch them with automated tests. You need humans in the loop.

But you also need to know when something is wrong. You need to know when the model is giving bad answers. You need to know when the retrieval layer is returning irrelevant documents. You need to know when the system is slow or unreliable.

So your monitoring needs to measure the things that matter to your business. Not just uptime and latency. But accuracy. Relevance. User satisfaction. Business outcome.

I’ve seen teams where one person understands the entire system, and that’s a disaster waiting to happen. But I’ve also seen teams where nobody understands the whole picture, and that’s worse. You need monitoring that bridges that gap. Monitoring that tells the story of what your system is doing and why it matters.

Getting Started: The Diagnostic Sprint

If you’re not sure where you stand, we offer a Diagnostic Sprint. Two weeks to a clear picture of what you have, what you need, and what the business case looks like.

Our Diagnostic Sprint is a two-week engagement where we talk to the people who built the system, the people who maintain it, the people who depend on it, and the people who own the business outcome. We audit what you have, identify the gaps between what you’re measuring and what actually matters, and build a roadmap to fix it.

We talk to more people. Because the problems are never where you think they are. The person who built the system sees one set of problems. The person who maintains it sees a different set. The person who uses it sees yet another. And the person who owns the business outcome sees something completely different.

Only by talking to all of them can you get the real picture.

The News: Security and Governance Are Top of Mind

This week, the security landscape got a lot more urgent. TechCrunch reported on a major cybersecurity incident affecting the internet broadly, while OpenAI announced a coordinated disclosure effort for critical vulnerabilities discovered by AI agents. This matters for AI systems specifically because it highlights how quickly vulnerabilities can cascade, and how important it is to have visibility and control over your own systems.

If you’re running AI systems in production, this is a wake-up call. You need to know what’s in your system. You need to know who can access it. You need to know what it’s doing. And you need to be able to respond quickly when something goes wrong.

Security and governance aren’t nice-to-haves anymore. They’re business-critical.

FAQ

Q: Does good governance slow down development?

No. In fact, it speeds it up. When everyone knows the rules and the system enforces them automatically, you spend less time arguing about what’s allowed and more time actually building things.

Q: How do we know if our access control is good enough?

Ask yourself: can I explain to my board exactly who can do what? Can I prove it? If someone leaves the company, can the system still function? If someone makes a mistake, can I undo it? If the answer to any of these is no, your access control needs work.

Q: What’s the difference between monitoring and audit trails?

Monitoring tells you what’s happening right now. Audit trails tell you what happened in the past. You need both. Monitoring helps you catch problems. Audit trails help you understand how you got there and prove it to regulators.

Q: How do we handle data freshness in RAG systems?

Start by defining what “fresh” means for your use case. Is it hourly? Daily? Real-time? Then build your data pipeline to meet that requirement. Then monitor it. Then audit it. Then prove to your customers that you’re meeting that requirement.

Q: What if we’re just starting out with AI?

Start with security and governance in mind from day one. It’s much easier to build it in than to bolt it on later. And it’s much cheaper.

Let’s Talk

If you’re building AI systems, you’re going to run into these problems. The question is whether you’ll run into them in production or whether you’ll catch them before they become expensive.

We’ve seen the patterns. We know the questions to ask. We know where the problems hide. And we know how to fix them without slowing you down.

If you want to talk about where you stand, reach out. Email us directly: hello@aartian.com. We reply within a day.

Or if you want to move faster, we offer a Diagnostic Sprint. Two weeks to a clear picture of what you have, what you need, and what the business case looks like. It’s the fastest way to get from uncertainty to a real plan.

The choice is yours. But the sooner you get this right, the sooner you can stop worrying about security and governance and start worrying about the business problems you’re actually trying to solve.