I’ve just published a new Udemy course on the Obot MCP Gateway:
And honestly, this isn’t something I set out to do at the start of the year. It came out of the last few months of getting properly hands-on with MCP and realizing there’s a bit of a gap between understanding the idea… and actually being able to use it.
How I got here
A few months ago, I joined Obot.
I already had some awareness of MCP — the Model Context Protocol — but it was more background noise than something I’d really dug into. Joining Obot changed that pretty quickly because MCP is kind of foundational to how things are built. So instead of skimming docs or watching from a distance, I was suddenly working with it day in, day out.
And that’s when things started to click.
The enterprise lens kicked in pretty quickly
Coming from an enterprise background, I tend to look at things a bit differently.
It’s never just about whether something works. It’s about what happens when it really gets used:
- How do we govern this?
- How do we secure it?
- How do we see what it’s actually doing?
Because that’s where a lot of AI setups start to feel a bit shaky.
You can wire up a model, connect some tools, maybe wrap it in an agent framework — and it works. But if you step back and think about running that in a real organisation, the cracks start to show.
- Where is context actually going?
- Who controls access to tools?
- Can you audit what happened after the fact?
- What happens when something breaks halfway through a flow?
That’s the point where “it works” isn’t enough anymore.
Why MCP (and gateways) started to make sense
This is where MCP started to feel less like “another thing to learn” and more like something that actually solves a real problem. It gives structure to how context is handled. It introduces consistency in how tools are exposed. It starts to turn what would otherwise be a messy set of integrations into something more deliberate. But the big realisation for me was this:
MCP on its own isn’t the whole story — you need a gateway.
In Obot’s case, that’s the MCP Gateway. But there are other gateways out there, and there will be more. The important bit isn’t which one you use. It’s the pattern.
That layer in the middle is where you can:
- enforce governance
- apply security controls
- introduce observability
- control how models interact with real systems
Without it, everything is just directly connected. It might work, but it’s hard to manage, hard to secure, and hard to trust.
With it, you start to get something that looks like a proper architecture.
Why I decided to turn this into a course
Over the last few months, I’ve basically been learning this the long way. Getting things running, trying different approaches, breaking stuff, fixing it, and slowly building up a mental model of how it all fits together. And the more I worked with it, the more I realised two things:
- This is where things are heading
- There isn’t a huge amount out there that helps people get started properly
There’s plenty of high-level talk, but not much that bridges the gap between:
“I get the idea of MCP”
and
“I can actually build something with it”
That gap is exactly why I created the course. Not to focus on just one tool, but to give people a jump start on the thinking behind it:
- how MCP fits into a broader system
- why gateways exist
- what problems they solve, and
- how to actually get something up and running
What you’ll learn
This isn’t just a theory course. You’ll get hands-on deploying an MCP Gateway, connecting models and tools, and putting the security, governance, and controls in place that production AI systems need.
It’s not really about Obot (just)
The course uses the Obot MCP Gateway because that’s what I’ve been working with day-to-day. But the bigger goal is to help you understand the underlying principles, because those are the bits that will stick. There will be multiple gateways. Different approaches. New tooling.
But enterprise needs won’t change:
- governance
- security
- observability
Once you understand how MCP and gateways address those, you’re not tied to any one platform.
How to get started
Publishing this course wasn’t about jumping on a trend. It was more about recognising a pattern early — especially from an enterprise perspective — and trying to make it easier for others to get up to speed without having to piece it all together from scratch. If you’re starting to move beyond simple AI demos and thinking about building something real, these are the kinds of problems you’re going to run into.
This is my attempt to give you a head start:
