Build an Infrastructure - Over Lunch - That Developers Want to Use
Given at VMware Explore on Tour London on .
Handing developers a Kubernetes cluster isn't handing them a platform. This talk walks the path to production as a developer actually experiences it, shows why an opinionated platform as a service on VMware Cloud Foundation gets code to production faster than a container service, and then demos Tanzu Platform from both sides: a developer pushing an AI app and binding a model, a database and an MCP gateway, and the platform team watching costs, vulnerabilities, SBOMs and every MCP call from Tanzu Hub.
Slides
Resources
- Secure your open source software with TrueSource by Broadcom
- TryTanzu - check out the Tanzu Platform with a 90 day trial.
- Platform as a Product paper
- Don't build your own platform paper
- Enterprise-grade platform engineering at Charles Schwab: three engineers, the whole Cloud Foundry estate, and the Log4j story
- How Two Operators are Continuously Patching Pivotal Cloud Foundry, the Wells Fargo repaving story
- Governance at Scale: Securing the App Estate, Erik Scales of Schwab with Valentina Alaria, VMware Explore 2026
- Inside the Coding Agent-Powered SDLC: Adapting Your Infrastructure, Adib Saikali and Frank Denneman, VMware Explore 2026
- CNCF Platforms White Paper, and the 2025 DORA report
- Tanzu Platform, the product page
Transcript
Over brunch, with a co-speaker
(0:00) Hello. Thanks for coming to my talk. When we do these Explore on Tour events, we give the talks that were originally given in Las Vegas. At the time, that one was at lunch, but since it's this time of day, I think we're going to do it over brunch. I'm sorry you weren't able to get the meals, but there'll be some available afterwards. We call that second brunch, if you're keeping track.
When they send you to professional speaker school, they tell you that you shouldn't begin a talk by talking about the talk and warning people about it. However, it's that time of year where my family of four other people has been sick, so I brought a co-speaker with me: Day Nurse. So if I start to be more loopy than usual, enjoy it, I guess, and tell me what happened afterwards.
(1:03) Speaking of, here's an official disclaimer. While you read this, you can think about what's going to be available afterwards. If you want filter coffee, it's fast to get, or you can wait in line for the coffee you actually want. You might want to take a picture of this, put it in your scrapbook. It's good stuff.
Platform as a product
(1:31) I assume you were at the keynote this morning, right? You've probably heard this notion, I think Paul Turner said it, of thinking about your platform as a product. That's something we in the Tanzu world have been thinking about since, I don't know, maybe 2015 or so, and it really is at the heart of what the Tanzu Platform is and what we do. This quote is from Thomas over at Mercedes. He managed the Tanzu Platform there for some time, and now he manages all the platforms, which is great for him. (Platform as a product white paper; Mercedes-Benz talks: one, two.)
(2:01) A fair amount of this talk is going to be: what does it mean to run and have a platform as a product? Of course, I don't have the fanciest graphics, but what that means is this. We, the Tanzu people, are those two little green things up there. I'm biased, but I think it's perhaps the most valuable part of the whole thing, because you can build out all this infrastructure, and then what you have is a fantastic, secure, everything, blinking cursor. It's just ready to do something, right? What you need to do is run applications on it, and hopefully applications you've written yourself that make your business operate the way it should.
(2:46) If we want to get a little more in there, we can zoom in to see the different parts of the platform: the things it does, the languages it supports, the people who use it. But really, what I like to see is, yeah, that's great gradient stuff I made in PowerPoint, what does the actual platform look like?
(2:56) This is from our docs. It'll give you a sense of what's in the platform. You can see it layers on top of the infrastructure down there, and you've got all the various things in it. If you're into reading documents, I'd suggest you check out the docs, because they're quite good and fun. (CNCF Platforms White Paper.)
So if you have a product, you have a customer, right? I'm going to go over what it's like to be the customer, a developer using it. And also, you'll hear me say the word "platform engineer," because that's what us people up in the stack say nowadays, what it's like to be an operations and infrastructure person. Those two perspectives.
A gnome buying shoes from a goblin
(3:36) To do that, we're going to observe a gnome buying shoes from a goblin. Why I bring that up is that I've been using AI for about three years to play Dungeons & Dragons by myself, which is either sad or fantastic, depending on what's in your schedule and your ability to make time for that kind of thing. So that'll be the example application. I sadly didn't work at the Acme Insurance Company, but I think this is a little more interesting, if you're into that kind of thing.
Who the platform's customers are
(4:06) So, like I said, you have platform as a product. Hopefully with a product you have a reason for existing, and you've got customers, so let's walk down to find out who your customers are, who your users are. Your first customer is always the business, right? They don't really care about any of the stuff I just showed you. They're like, we've got to do our banking, we've got to sell our insurance, we might want to move product around, whatever it is. So you start off with the business people, who always have fantastic hair, if you've been around them.
(4:36) And then they're like, we've got to have applications. So you get some developers, right? You've probably met some developers. Maybe there are one or two, or 1.8, developers in the room. They're great. They're relaxed, they're always typing stuff, playing a lot of foosball.
(4:48) And nowadays you have what some people might call a centaur developer: the human on top, and the robot, the AI, underneath, driving things, doing development.
(4:56) Of course, I always like to understand something by thinking about the opposite of it. I guess you could also have a horse-headed developer. I'm not quite sure what that orientation would mean, but you might have that as well. And this need for applications, to buy shoes from a goblin cobbler or whatever your business may be, gives rise to the need for platforms.
(5:22) It's always fun to read these predictions, because similar things were said in 2014, which is great. We're progressing, evolving, iteratively. But you see this proliferation of platforms out there, as shown by surveys like Gartner's and DORA's. And then we introduce the fantastic platform engineer, the operations person who's dealing with all of this.
The development workload is growing
(5:46) In addition to the traditional way of doing platforms, the effect you start to see from running and supporting a platform is that development is changing, of course, incredibly, because of AI. This is just one way of looking at it. GitHub published this: it's the number of PRs and commits that have gone in there, and you can see the huge rise in it. (The Pragmatic Engineer, GitHub.) I'm an application person, so tell me if I'm making stuff up, but it seems like as infrastructure people you should be like, oh my god, that is a huge workload coming at me, something I need to handle and start working with.
(6:21) Because traditionally, in the SDLC, the software development lifecycle (it looks like everyone's old enough to know what that means), most of the compute and work is done over here. Product management, design, developers build things. Sure, they've got laptops, but there's only one area where there's a huge amount going on: production, and maybe staging and test. Over on the left it's all laptops, and the machines under developers' desks that they never actually turned in when those were phased out.
(6:56) We see this in Tanzu, where we've been as AI-nuts as anyone over the past year. What's happening is the development workload goes all the way back to the idea. Your product managers, for better or for worse, as the developers would say, are building full-on products, just telling the little robot what they want. Design builds products. They deploy that stuff. They want to integrate it with all the data and things you have. Essentially, instead of one developer, depending on how you do things, you've got two more developers bringing that same workload to the platform. They're rapidly going through it: if you're that nicely haired guy, multiple times a day you're deploying something new so you can test it out and see what the application looks like.
The normie workload
(7:41) Now, there's a new workload that I think is just barely starting to come in. One of the things I want to encourage you all in the room to do: someone is going to get this workload, and I think you are probably the best people to get it. I was talking with someone earlier who works at my bank, and I would prefer the infrastructure people at the bank I use manage this workload rather than some other people. I think it'd be a nice, reliable thing. I like the money to be there when I need it.
(8:12) For better or worse, I call it the normie workload. Think about everyone outside of IT. If you've used Claude Code or Codex or something like it, imagine you gave those people Claude Code and they used it every day to do their things. If you've ever used it, it's fantastic, it does everything you want. That's a huge increase in usage, a whole new workload to start worrying about. (Accenture and the tokenpocalypse.)
(8:43) As the CTO at ING said last month or so, think about it as letting Excel into the data center. That's the equivalent of what we're talking about. Not only is it running on something you host, it's programming and running things.
(9:01) And not only for that one person. Think about the thousands and thousands of normies who are out there. You've got maybe half a percent or one percent of your organization who are developers, and 99% are normies. That, I think, is coming in the next few years, hopefully for all of us, because if it's not, this whole AI thing isn't going to work out, and that'll be terrible. But hopefully it'll spread to all of these people, and that's a new workload to start thinking about in addition to the developers.
Who's talking
(9:31) This is actually me. I started out at Pivotal, then VMware acquired Pivotal, and then Broadcom, and somewhere in there we named ourselves Tanzu, but it's been the same thing: working on a platform, an application server, a PaaS. I used to be an application developer. I was an industry analyst at a place called RedMonk. My former boss, James Governor, is running around here somewhere. You should go talk to him. He's fine. I've been really lucky to be in the same job for a while, what we call developer advocate, devrel, or evangelist as we'd have said at another time. I spend my time studying large organizations: how they use software, how they run it, how they make it better. I've written some books and I've got some podcasts and things like that. As one of my friends used to say, engage with my brand. Enjoy.
Let's build a platform!
(10:17) So, you need a platform. The developers need a platform, and eventually they're going to come to infrastructure. Well, they probably don't want to come to infrastructure, but eventually they will. Before that, as a former developer, I can tell you there's nothing a developer likes more than building a platform, building infrastructure. They're psyched about it, instead of building another pagination framework. They get really excited.
(10:41) The other thing you've probably noticed is that whatever platform you might be offering, it doesn't have what they need. They have very specialized needs for their workloads. For some reason, the way they do insurance auditing is completely different from the way every other organization in the world does it. So they need to build a bespoke machine, a bespoke platform.
(10:56) My friend Oren, and you can see some of his talks later, uses this metaphor: they need a perfectly built coffee machine. They get excited about it. They start building it out.
(11:06) What happens, of course, is that the more successful your organization, the larger it is, the more developers you have, and the more special requirements they have. They build out all these platforms to support their needs. I'm sure everyone here has only got one or two platforms. It's great: you don't have to deal with this variation, you've never had to modernize things. But when you talk with your friends, you can be sympathetic, because what ends up happening is you get a landscape of somewhat working platforms.
(11:36) The developers don't realize they're helping reinforce the credo of platform engineers and operations people. It really is the effect that happens every single time with infrastructure: someone else built something and moved on, and now it's your problem to deal with and run.
What developers actually want
(11:57) I was talking with someone at a large bank yesterday, which I guess is a humble brag, and their concern is: how do we build a platform that developers want to use, so that not only can we avoid having to manage their mistakes, but we can do our job of making sure our stuff runs and works? That's what I'm going to get into quite a bit here. What does a developer want?
They don't always tell you what they want. I remember one anecdote from someone: we built out this Kubernetes platform for the developers, and a year later they weren't really using it. So we went and said, what's the deal? You told us you wanted a Kubernetes platform. And they said, oh, that's just what we said because we thought that was all you could do. They weren't really communicating what they wanted. So let's look at what it is they end up liking, if you understand the customer and work with them.
(12:56) Again, platform as a product. That means you're product managing the platform, you're looking at what your customers are doing. So let's take a little tour of what developers do nowadays. You've got your friendly centaur over here. I don't know what the horse head does; maybe we'll get into that later. This is representative of what goes on in the cloud-native world. They build their code, they set up the big executable chunk, it goes into a pipeline, runs all sorts of tests, and then, depending on how you do it, it deploys out onto the cluster and the system provisions all the fun things. (Source: "Inside the Coding Agent-Powered SDLC," Explore 2026.)
But as you know, part of why that litter of coffee machines is bad is that after the first few things, it ends up looking more like this. And then you bring in your AI agents, and the AI agents don't care what you want them to do. As we've learned, they'll just go right up into your image repository and do things. If what you're saying is, hey developers, here's the infrastructure and here's the documentation, please do it the way I'd like you to: developers are very good at not listening and going around you to do whatever they need to.
(14:15) So the approach we've had for a long time, and of course I'm going to show you our stuff, is that a platform takes a declarative approach to things. What it says is: I don't want you to go and configure everything and mess around with everything. We're the platform people, and you just tell us what you need in a declarative way. I've got an application, here it is, I need this database, I need these networking routes between these things. We use an open source technology called Buildpacks.
This is a sample of what it looks like. Of course, you see it's just one line of code, and you're like, yes, I'm sure that's one line of code supported by five million lines of code. There's a lot of stuff behind it. But the point is that this is the interface developers who use our platform have into it. And you can see this is a great situation for AIs as well, because you're not letting them configure things however they want. They're just telling you what they need in a declarative way.
It's a very simple representation, but think about how you remove what some people call the cognitive load: having to think about how to configure all this stuff. A lot of developers end up in a place where it's, you want to deploy your stuff to clusters? Write some YAML and figure it out. Instead, if you take this declarative approach, you get all sorts of benefits from the platform building things, instead of having the developers build everything themselves, which is often a kind of crazy approach.
The developer's perspective
(15:53) Now, as promised, let's see what this looks like from an application standpoint.
(15:56) Here's an example of me either having fun or living my sad middle-aged life where I'm playing a game on my own. I'm going to show you how this all happens from a developer perspective. You load up Claude Code and say, let's play. Let's get the gnome; he wants to go buy some boots from a goblin, and we're going to have AI running all of that. If you know Dungeons & Dragons, or maybe you've seen Stranger Things: you go on quests, you have NPCs, non-player characters, which is what the goblin is, and you've got a PC, a player character. You sit at a table, if you're not like me, with actual humans, and you go on an adventure to find some treasure or rescue a person. But there are other situations where you're just talking with someone, and here we're trying to get some cool boots we can hide stuff in. So how do we do all of that from a developer perspective with our platform? I'll show you the overview of what everything looks like, then we'll look at some steps, and then we'll look at how platform people manage everything that supports it.
(17:04) First of all, here are all the steps it takes to get to that point. You can start to see the different areas of things that are running. I guess the VCF world is over there somewhere off the page, because it's actually running all of this on top of it, which is fantastic. We appreciate it. You can see I log into Claude Code here and say I want to buy some shoes. It's using Model Context Protocol, one of the many API-ish things for doing AI. I SSO into that, so it's authenticated to me, which you'll see is great. And then that finds this application we made called the NPC application.
What has to happen is you've got to inject, let's call it, the soul: hey, you're Grubnik the cobbler, here's your worldview, who you are and how to play it. You've got to insert the memories into it. It handles all of that because we're binding databases. Remember the declarative manifest: we're saying we need access to this database and to that memory, and the platform wires it together. Then we pass off to whatever AI we're using. Here it's an on-premises AI, because as we learned this morning, the other kind is very expensive. Except if I run on my friend's thing, then he pays for it on whatever Nvidia stuff he's running, which is great. And then the cobbler's like, I don't know, do I give him some shoes or not? It replies, and that goes all the way back up the chain. All of this is running on a platform. Well, except for the Claude Code part and me. I run on a me-form, I guess. But it all runs on the stacks you've been seeing today.
(18:37) Let's get a little bit into it. This is the command a developer runs after they've written their application. All they're doing is pushing this to production, and then it deploys. Very exciting. They go get some coffee, and then it's done running. This doesn't really tell you anything, it looks like we just typed a bunch of stuff, but it gives you the idea of what it looks like for a developer. There's the command up there. That's all they're doing. They're not editing a bunch of stuff or figuring out how to wire a database together. They just have that one YAML file.
(19:10) If we look at what actually happens there, here's that manifest again. We've got a name for our application. It's in Spring, of course, because I'm a Tanzu person: a Java application. Here's our executable, here's the profile of what I need to run it, the route I'm going to set up, what I'm going to call it, and the model I want to use down here. And I'm binding it to the brains, or the soul if you will, of our friend the cobbler, and to the memory it has. That's the total interface. There's a little bit more, but that's the main interface for a developer into the platform.
(19:41) And here's what you see in Hub. Like I said, we've got our infrastructure down here, and the platform is building out this entire thing. Right now it's injected some tracing in there, and I'll show you that tracing in a little bit. It builds this out and sticks it in this space. Remember, I've authenticated to it, so it knows which user is accessing it and what permissions they have. It's all set up. It's a platform, a platform as a service, as you'd expect. The developer didn't have to spin up VMs, figure out containers, all that stuff. It's all done for them. And you have control over it, which is not a word you want to use with developers, but you can assist them in setting up their things, which they'll appreciate.
(20:16) So I'll go over one service. Like I was saying, the goblin needs to remember things. Early on when I was playing D&D, the best integration you had was copy and paste. If you remember three or four years ago, you had the chat window and no way to get stuff in and out, so you'd copy and paste through it, which is a great API. But when you ran out of context, you'd go to a cobbler and say, hey, I'd like some cool boots with secret pockets, and a few hours later, after I've been playing, I'd go back to the cobbler: where are my boots? And he's like, I've got no idea what you're talking about. The context window had run out, and there was no memory. So one of the core things you need to do is get some memory into your Grubniks, into your NPCs.
This shows that. I showed you a bit of the manifest and what the developer does, and like all command lines you have to know the order of things for it to make sense. What's happening is we've deployed the application, and now we're declaratively saying to the platform: I'd like to attach the memory to this instance of an NPC. I'm not giving you a bunch of configuration and port numbers and queries, I'm just giving you names for what's in there. Again, it goes into the platform, and you can see where the platform starts doing things. The platform is the one binding all of that, making sure you have access to it. Again, you have full assistance potential for the developers there. And it's also what lets you scale things up and down and do rolling deploys, all of that kind of stuff, because you're managing the bindings. And then our little friend has a memory, and he remembers the boots we talked about.
(22:01) Again, this is over in Hub, and you can see how that works. If you look up here, you can see it now has memories. I'm going to skip over adding in the soul, but it's built up this whole thing on the platform layer, just from the developer using that manifest and doing these bindings: I'd like to hook these things up. Not a lot more work.
(22:31) And finally, I think one of the more exciting things: if you've tried to use MCP in the past two years, the authorization was terrible. That's the kind of thing you want to build into the platform, so that SSO is extremely easy, and in the platform it is. If you know the OAuth dance: I want single sign-on, using OAuth, for this connection to the cobbler. Do it. Otherwise the developers are left to figure this all out: how do I write the SSO integration into whatever the corporate standard is? That's something a platform, if the developer is lucky, does for them. You just follow the same declarative way of doing things.
(23:41) As a reminder, all of that and more, in a complex way, was happening just so I can get some cool boots from that goblin cobbler. But hopefully you get a sense of what it looks like for the developer, your customer, what their experience is, and why it's easier than if they were just given a blinking cursor and told to figure all that out.
The infrastructure perspective
(24:06) So let's look at what it looks like from the infrastructure perspective, the platform engineering perspective.
(24:16) We of course have the cool, dark, cockpit-y backgrounds everyone has nowadays. I realize you can't read this, but you can get the slides later. This is a comprehensive, or un-comprehensive if that's a phrase, overview of all the things Hub does. If you know what SDLC is, you probably know what a MOM is, a manager of managers. Hub is our interface on top of everything that's in the platform. And of course it does all the things you'd expect for running applications, and has a service catalog for... I wish we had a better name for services. When I was younger we'd call it middleware, which seemed great, but you don't want to say "we've got a service catalog for services and we run a service," you're saying "service" all the time. Whatever: databases, event queues, access to inference, all that stuff.
There are security things there, and what I think is great that we've been adding recently, and you saw a little of this this morning, is not only securing things but getting very detailed about which patches need to be applied, finding them, tracking them down. And because the platform is building all this, the platform can go patch it without having to arrange a meeting with the development team to patch their stuff. You can do a fair amount of patching without bothering them, which means you can do it faster and assist them more.
(25:43) I mentioned the MCP stuff, and this is one of the more exciting things for me. If you remember BMC Software, I guess they're still around, I used to work there, and I spent lots of time running around in SNMP and tracing things. So I get really thrilled about being able to do this kind of stuff. This is what we track in Hub: an incoming MCP call. As with everything, you wrap a gateway around Model Context Protocol, and you wrap a gateway around inference, around accessing AI. That means instead of going directly to something, you can sit there and sniff, or audit, or look at all of the access, down to a person. That's because you're using the MCP gateway that's in the platform.
When I had my agent do this, it was so polite it took out my actual email address. I didn't want to tell it how to live its life. But you can see in the logs, which you can go search, exactly what's happening with each call. Obviously in a real production environment you're going to do sampling, and if you want to store all of it you're going to call our storage friends. They'll be very happy about their quarter. But the point is, you get access to everything you'd want to look at.
(26:51) And what I find even more exciting: I'm going to switch over to OpenTelemetry stuff. You can configure this into Hub, but I like to show that you can use whatever technology you're interested in. There's OpenTelemetry built into the application layer and the platform layer, so if you point it at Jaeger and look, you can see every interaction that's happening.
From an AI perspective this is fun, because part of what you need to do with AI is figure out what works and what doesn't. How you do that is you look at transcripts and interactions, the little thumbs up and thumbs down. Again, you'll be sampling, not looking at every single thing, but you need to observe what these chat windows are doing. So you can set it up, as was done here, to send your traces to whatever supports OTel.
Here's an example of exactly that. We've opened up a trace from that window we saw, and you can see the message that came in. What's really interesting, if you're into this, is you can see the train of thought the agent is having. You can see exactly how Grubnik is thinking. From a player perspective, you're just making moves, but here you can see how he reasoned through it. Think about that in a business application sense, whether it's customer service, loan analysis or approval, or something more entertaining. You can see exactly how the AI is thinking, and you can keep track of it to audit it, to have a record of what happened if you need to store that. You get this great view in, and it's all because you're running it on a platform: you can wrap things around it to capture this and send those transactions out.
As one example, when I was doing this I found that I had an MCP server for rolling dice, and it would take about two seconds, which is annoying. I was like, oh, that's stupid, I should just build that as code in there. So you can start optimizing how things work, which is fascinating, again, if you like MIBs.
Patching, repaving and SBOMs
(29:11) Of course, security: we should all be freaking out, right? This chart isn't even updated, it's up to 100,000 now. If you look at the CVE growth, due of course to our friend AI, it's a bittersweet sort of thing. More sweet, hopefully. But this is another thing the platform can now be responsible for.
(29:36) This is something we've worked on in the cloud-native world for a long time. One of our early customers was Wells Fargo, and what they would do is redeploy all of production multiple times a week. At the time we didn't have frontier AI models, but the reason they did it is that it would wipe out any malware they had. (How two operators are continuously patching Pivotal Cloud Foundry.) If you can deploy an application multiple times a week, that's more or less the same as redeploying the same application. That's a great approach for dealing with CVEs and other issues. You can be targeted about it, but just repaving multiple times a week takes care of a lot of things for you. Again, you're assisting the developers with how they package and build their code and configure and run it in production, and you get the ability to do this during the week instead of on Saturdays.
(30:31) So let's look at what this looks like for the infrastructure and platform engineering people. I guess that's you, if you're interested. A CVE comes in. You go into Hub, or whatever you like from the Broadcom family, and you dig down. Because it built all these applications, it knows everything: what's in the layers, the SBOMs, as I'll show you. And then we have something called Application Advisor, which will tell you, okay, this CVE applies to this version of Spring. Maybe you run the most recent version of Spring, but if you talk with your friends, they'll say, I don't even know how many versions of Spring and Java we run. It's fantastic. So often you're just finding what it is. You need inventory.
What Application Advisor will do is use another open source thing called OpenRewrite to generate a PR, which is the change you're going to make to the code, and send it to a developer to look at, so they're part of the process. And then it goes through that whole process of building and rolling things out.
(31:31) To see what that looks like in Hub: here we're seeing very similar things to what you saw this morning. The applications we have, the various levels of CVEs we have, and we drill down into that.
(31:53) We're looking at one application here. And again, one line of code. This is the start of a recipe: if you have this version of Spring and you need to upgrade to that other version of Spring, let's load that up.
(32:06) I'm sure you're fascinated to learn more about your customers, the developers. This is a little of what it looks like in code. In OpenRewrite there are these recipes that go in and search the code, change things around, and they have a way of validating it. Very thrilling, if you like code, to see this done in an automated way. Of course, it doesn't do everything in the world. It doesn't make you smoothies and it's not a floor wax. But it does a huge amount of the work that normally you would spin out to developers to handle, and just hope they do the right thing. Now you're involved in the process.
(32:41) Speaking of inventory, you've got to have an inventory of things. In the UI, you can come in here. I just discovered this new feature: you can move this around. Very exciting. You can go find the offending thing, you can download the SBOM. Everyone loves an SBOM, right? And you can see what it looks like.
(33:06) More realistically, maybe you're going to use a command line to do it, instead of the click-ops. I think the Day Nurse is speaking. You go to the command line and query for the thing you're looking for. There's our application, and here's our nice SBOM, in a comfortable terminal. I thought it'd be fun to see what's in an actual SBOM. People talk about them but never really look at them. So here you've got a full SBOM of the 150 or so components in there. Any of them could be an issue. And you can also make a fun animation at the end. Now you've seen a real-life SBOM, so next time someone talks about it you can say, oh yeah, I've been SBOMed before, I know all about it.
Foundations, and supporting open source
(33:57) So how do you get this running? Being part of the Broadcom family of excellent software and craftsmanship, it layers on top of VCF fantastically. We don't always say this in the first meeting, but it runs on other infrastructure as well. Don't tell anyone I told you, just in case that's something you're interested in. It runs best on our own technology, but some people don't get to make all the best choices. They have to make compromises in life and balance things out.
We think about what we have as various foundations, a way of thinking about the functionality you have. You saw some of this this morning. If you want to do AI, there's the Agent Foundation, which collects together things for supporting agents; you saw Purnima doing some of that on stage. You saw running your own private AI this morning, and you can set up the gateway and the proxy and the access to that, or to other services, all in a way that's easy for developers to use. There's a GUI for developers too, but they don't use that, they all use the command line. That's the interface for them.
Then there's the plain old Application Foundation: how do we make any type of application, bring in the services I need, build things out, whether it's in Java or TypeScript or, I don't know, people use Python a lot. All those consultants you brought in two years ago to build your AI stuff: that's a good example of not my mistake, now my problem. I don't know if you have a pile of Python you know how to manage. Those forward-deployed engineers became rear-deployed engineers, so have fun with that. But it's basic application things. And then of course you've got the services, that middleware stuff I was talking about, and so forth.
(35:41) And back on the security thing, another thing I think is really important to pay attention to, and not just because I work here: we've got to patch our stuff. In the past year we've dealt with this ourselves, we've taken a lot of those learnings, and Purnima talked about this quite a bit: we now have coverage for the open source world, support you can have that integrates right into the platform. (TrueSource, the announcement, TrueSource Trusted Artifacts docs.)
For something like Spring, we employ all the people who work on open source Spring, which I'd say is the most widely used Java framework. And Java, I think, is the most widely used language for enterprise applications, so Spring is the most widely used framework for enterprise applications. We have all the people who work on that, so you can get support, including that application rewriting, and depending on the situation, access to patches before they're made public, which is great. If you happen to be holding my money, I'd prefer that.
And it's not only for the application layer, for Spring and lots of the Java application stack (not the whole one, I've got to be careful, remember the disclaimer at the front). We also have Bitnami, a very secure, clean-room-built registry of things. That, along with several other things, is built on the same idea: you need security support to get patches as soon as possible, in a way that's easy to deploy into your environment, plus normal open source support, like 24/7 support if you have a question and want to talk with people. And then we've combined together the various database things we have across the VMware and Tanzu world. If you've ever used DSM, which is, I'm going to blame the Day Nurse here, Data Services Manager, we've combined that with the open source data management we have in Tanzu. So you've got coverage over all the great open source databases and event queues, plus SQL Server, where you can bring your own license. It's the same idea of bringing security support in there.
Apps per operator
(38:01) So finally, I realize you can't read it now, but if you don't want to take my word for it, you can go look at all these happy customers who have done things. This is the platform engineering perspective: yes, that works, and here's the benefit from an operations standpoint. One of the things I like to collect over the years is ratios of the thing you're supporting to the number of people supporting it. To me, that shows the efficiency of the platform. (Charles Schwab, Rabobank, a decade of Cloud Foundry, Platform engineering: what you need to know now, talk one, talk two.)
Up here it's a pretty wide span, but you can see one organization has four operations people supporting 1,200 applications. That's because they're running this platform instead of building and managing a platform, and because they follow the practices I was talking about. There's another organization down there, I forget which one, you can read it yourself, where a very small number of operations people are supporting a huge number of people.
If you're like me, you're thinking, it sounds like you just said I'm going to get fired. Hopefully labor laws make that a lot more difficult. But I think it's more: remember all those normies who are coming, and remember the well-haired people. I guarantee you, if you told them, we can support more applications, they'd say, I'm going to clear my calendar for next week, let's talk about that. I don't think anyone in an enterprise has ever said, you know, I think we're done, we've got enough applications, we don't need new features, let's pack it up and go home early today. They always want more, as they should. If you can say, we can manage these ratios with the platform, you can start to say, we can do more and more, and hopefully you're no longer the Department of No, of "well, but...", and instead you're saying, we'll help you out with this stuff. Which I think is fantastic.
Dig deeper
(39:59) To relate it to one more thing, you can see how it fits into the wider infrastructure world. I'd encourage you, if you really want someone who knows what they're talking about in the VCF infrastructure world (I could talk to you about application development all day long), to go to the two other sessions Oren is doing, later today and tomorrow. Unlike me, he doesn't start from the top and wave his hands as he falls down. He goes in the other direction. He's very skilled and knows what he's talking about. He'll start from the infrastructure layer and build up to exactly where I ended, and show you how it fits: all your, whatever you say, zones, regions, failover. I don't know, I'm a developer. That's your problem to deal with.
(40:51) So with that, what I like to encourage people to do: if you feel like you've wasted your time here, I don't want to waste any more of your time. You don't need to fill out a survey. Go move on to something else. You can leave early, get in that line, get the machine-made coffee, which is slightly better than the filter coffee. However, if you did enjoy it, take a little bit of time and fill out the survey, which would be great. I don't really ever see the results, but they keep inviting me back, so maybe it's good. Beats me.
(41:26) Again, you should go see the sessions Oren's doing if you want more detail: "Stop Building, Start Vending: Deep Dive into VMware Tanzu and VMware Cloud Foundation 9," EOT1357LON, Wednesday at 16:00, and "0 Code Agents: From AGENTS.md to Running App on VMware Tanzu Platform," EOT1669LON, Thursday at 10:00.
(41:35) And if you're interested in talking more or getting the slides, I have a page here that has the slides and all of the references. Well, not all of them, the ones I think are good, lots of the things I link to. You can click on the footnotes in the slides and stuff like that. And with that, thanks. I appreciate you sticking around.