7 Ways to Fail at Building a Platform
Given at the DevOps Amsterdam meetup on .
Everyone's thinking about building an AI platform right now: one place to run all the new apps that takes care of security, governance, deployment and monitoring. And, of course, the instinct is to build it yourself. Drawing on ten years of platform engineering at large organizations, this talk goes over seven ways building your own platform goes wrong: developer-built platforms (the day two hangover), unexpected scope, underestimating the ongoing cost, treating the platform as a project, keeping skilled people, resume-driven development, and keeping up with security and compliance.
Slides
Further Resources
- The Upside-Down Economics of DIY PaaS - Seven pitfalls of building your own platform
- Platform as a Product - platform as a product from 2017 to 2026.
- CNCF Platform Engineering Maturity Model - goals and milestones for your platform team.
- Coté's Books - going over how large organizations get better at software, most are free.
- Running Claude Agents on VMware Tanzu Platform - a reference architecture for hosting the Claude Agent SDK on a private, governed platform.
- Protect your registries for AI use, and humans too with TrueSource Spring Enterprise by Broadcom and TrueSource Trusted Artifacts.
In the room
Transcript
Why there are platforms in the first place
(0:00) Well, hello, thanks for having me. It's exciting to know that DevOpsDays Amsterdam is coming back. Always nice. To show off, I still have this wallet that y'all gave out to speakers a long time ago. It's fantastic, it's very handy: I can have two rectangles burned into my pants instead of just one like everyone else. So I'm going to go over a collection of things. I learned with this talk that you don't put a number in the name of your talk, because as you think about it, you're like, it's not really seven, it's eight, or it's three, but whatever.
(0:37) So I forced seven, and some of them are a little forced. But as I've been observing people building platforms, doing this kind of stuff to support running applications, here's a collection of things that have not gone so well. I think it's always good to start off with why you have a platform, this thing that runs your applications, because it's easy to lose track of. I used to be an application developer, and they really tell you to focus on the purpose of what you're doing. It starts off with having applications. If you had a platform, a Kubernetes cluster or something, and there were no applications running on it, that's kind of pointless.
(1:18) It might be fun and entertaining, but you need some reason for it to exist, often a business reason, as they say, which is always good to keep in mind. I remember a lot of discussions of developer productivity a couple of years ago, and most of them were like, "well, there's that whole part about making money for the organization, but we're not going to talk about that. We're going to talk about developer productivity." Which seemed like a pretty strong disconnect. Anyways, so you want to build these apps.
(1:50) The first thing you need for apps is some developers: people who are going to write the code and think about it. Someone's got to write these applications. Next up, of course, you have the centaur, if you want to think of it that way: the AI with the human doing things. They get involved in it, and that's exciting. As we saw, you can have AIs everywhere. And as I said when I was opening this, I always like to reverse something, so you might also have a horse-headed human. I'm not quite sure what that would be.
(2:20) The reverse centaur, I think people call that. So you've got AI involved, you've got people, you've got the business who want something, and hopefully there are also customers somewhere. I should remember that for next time; that's always good to know. So you want to write these applications and run them, and then there end up being people like the people in this room: the people who run the stuff, diagnose it, and keep it up and running. Nowadays you call them platform engineers, operations people (I always say ops people), infrastructure people.
(2:50) This gives rise to, as was kind of alluded to, a DevOps crowd, and you're like, "oh, it's great that we've rediscovered DevOps again, and it's finally going to take off this time." But there really is this sense that we're all building platforms out here, which is true. There's plenty of that going on. Just as a side note, we spent three to five years building up Kubernetes stuff, and we've got ourselves a blinking cursor now. So we've got to build a platform on top of that to run applications, which is fantastic. We're in that era.
What is a platform?
(3:21) So that gets to the question: what is a platform? Thankfully, the Cloud Native Computing Foundation has a reference architecture for a platform, so I can show you what a platform is without talking about vendor commercial stuff. With an extreme bias for my interests, of course, there's the best platform available: you can see its technical diagram, but don't look at that if you're offended. Over here you can see an outline of what goes into a platform. An interesting thing is that the infrastructure isn't necessarily part of it. Your platform is built on top of the infrastructure: you've got all the middleware you need, all the authorization, and sometimes it even goes all the way up. Remember Backstage? We had fun times with that being part of the platform.
(4:09) Maybe you even have the portal built into it, until you're like, "I'm sick of JavaScript," and stop doing that. But think about what the primary interface is for developers, whether they're horse-headed or horse-footed or human top and bottom. Those are the customers you're going for, running on top of the platform. And I think there's a new type of customer coming to the platform, hopefully to us instead of elsewhere. My wife always tells me this is insulting, but she's not here, so: I think of it as the normie.
The normie workload
(4:50) So we've got the regular person who's not technical. This is me in some alternate dimension, I think. And this person now has the power of AI with them. Think about all the great AI uses we just saw. That's us. Well, I just make slides nowadays, so I don't know if I'm really part of us. But you've got technical people using AI to build their things, and increasingly you've got those normie types who are making slides,
(5:20) or doing analysis or reports, whatever they do. And you see this slowly creeping up: more and more non-technical use. Of course, they have the same issues developers always have. You give someone a tool, and they end up wanting to do ridiculous things with it. But you can be kind of sympathetic to these normies, because that's a lot of what their job is. Kind of like we were seeing earlier, imagine the fog, not of incidents happening but of the business just processing, and you've got to reduce that big fog of something down to a slide. That's a lot of the work that goes on.
(5:20) So imagine that kind of absurd usage. I bring this up because it's fun to use silly pictures that I've made, but also because it's this oncoming workload. Now multiply that across
(6:12) thousands of these normies. Never mind thousands of developers: imagine every person in your organization has Claude Code, installs it on their desktop, gets a cup of coffee, and now they're off. That's a huge workload that's like developers, but also very much not like developers, and I think it's probably the domain of the people in this room, the people doing platforms.
This is me
(6:42) So this is me, very briefly. I work at Broadcom now. I came there through VMware, I came to VMware from Pivotal, and before that I was an industry analyst at a place called RedMonk, and some other places, for a while. I was an application developer, as I said, a long time ago. But I've been lucky to essentially study how large organizations use software and get better at it, write about it here and there, and do stuff. I have some podcasts if you're interested in that. As one of my friends used to say, engage with my brand. And then I'll move on.
(7:17) This stuff is based on some white papers we have, which I helped update, that have been around for a while, so I really like a lot of the ideas. They go over what platform as a product is, if you like that phrase, and the failures of building your own platform. And if you're thinking it, to say it obviously: yes, I work for someone who would like to sell you a platform instead of you building it. So you can take that as some seasoning on top of everything I'm covering here. But let's move on from that.
#1 Developer-built platforms
(7:52) The first one we'll call letting the developers build the platforms. A lot of these, like I was saying, are different sides of the same thing, but this is probably where things really start going wrong. Think about the needs the developers have. They've got to build these apps, they need all that middleware and stuff, they want a portal, and they're like, "you know what we should do? We should build a platform." I've heard everyone chuckle about how you've got to talk to the governance and security people. As a former application developer, what developers are saying is, "we've got to talk to the operations people? How about we don't do that, and instead we build a platform." And if you work with them, they always have very special needs. They can't just take a cup of coffee from a machine you have. No, no, no:
(8:38) they've got to weigh the beans, and then turn this knob and that knob. They need a very specialized platform to do something like approving expenses. But whatever, maybe they've got some great coffee, some good ideas, so they really want to build it out. They get very excited, they're totally into it, it's really great and challenging for them. And what ends up happening, across thousands and thousands of developers, is they build lots of great, perfect platforms, very interesting things. But developers have the attention span of a little more than a fruit fly, like one of my kids: "that was really fun, and now there's something else fun I'd like to do." And you often end up with a landscape of neglected, somewhat functioning, specialized coffee machines.
(9:29) And I'm sure, as operations people, you know that this brings in one of the credos of the operations person: "not my mistake, now my problem." You're handed all those coffee machines to manage after the developers built them, and now you've got a problem to deal with.
(9:29) There's a variation of this that I call the center of excellence from orbit. You might have something running, it's great, you've got a good platform, and it's always them, over there: there are some center of excellence people
(10:03) floating up there, thinking about things, observing the excellence. And then: "you know what we should do? This is all working fine over here, but there's a new industry standard, something new we need to be doing, so you should go and implement this." It's not so much the developers doing it as an external force coming in from orbit and destroying all your stuff that's working. So that's something to watch out for: the direction of why this platform is being built.
(10:34) One way of thinking about it, a very DevOps-y way, is: who's responsible for this? If you build it, who's going to be running it? If there's a disconnect there, that's a bit of an issue.
#2 Unexpected scope creep
(10:34) Next, you end up with a lot of misunderstanding of how much scope there is, how big a platform is, and therefore what you have to do. Just as a reminder, look up here again and you can see all the various components. Now, one response, now that I've looked at it a second time, would be that what you've got up there is what we call computers.
(11:08) It's basically everything involved in running an application and building it, which is kind of the point: running an application and supporting all the stuff around it is a lot of moving parts to coordinate and work on. People often build the initial cut of a platform, then they need to add new features, and they don't quite understand everything that's needed to support and run a platform. So think about all the sorts of things a platform needs to support, put into words. That's a little sampling of them, and some weird things come in here that aren't the tools you're building up: all sorts of different, as we might say, outcomes that must be achieved,
(11:51) beyond the scope of "we built this platform that runs things and monitors stuff." Without understanding the full scope you're going into, you get to this unexpected stage where you haven't really built enough. Another way of looking at it: you learn in slide-making school that you're not supposed to put a bunch of words on a slide, and I like to break rules at least once in any endeavor. This is an attempt, helped by a robot, to summarize the CNCF platform maturity model.
(12:25) There's a beta version that hasn't been looked at in a while, and an older version. But it's a great document if you're doing any sort of platform stuff: a group of smart, experienced people who came together to go over the activities you do when you're building a platform. What's interesting, to the point of scope creep, is that across all the activities, getting to about the midpoint is a three-to-five-year journey. Whenever someone uses that word, they don't mean pleasant. So it's a long journey, and the issue is that it takes a while to do the basic things. There are also some other observations in the great Platform Engineering book, if you haven't read that,
(13:16) about the timeline for these sorts of things. You go through a cycle of running with an MVP, as we used to call it, a scrappy platform, and then you need to fit into the next budget cycle. There's a really good story in there. It ends up taking quite some time to get to the full functionality of the platform you were shooting for. Now, of course, that assumes it works. I have a bit of a bias in the people I end up talking with, because they often don't talk with us if they're successful at a platform, or if things have gone perfectly well.
(13:49) But very frequently it's the first or second version of the platform. I don't know if you've ever been in this conversation where someone says, "you know, the last people who were here..." What they mean is that a team came and built something, and it didn't quite work out the way they wanted.
#3 Underestimating the ongoing investment
(13:49) Another part of scope is understanding how much it's going to cost you. There are many ways of figuring out the cost of things, and the simplest is just the salary you pay people. If you've got an idea of that scope, you can start to imagine how many people you need, not only to build that platform but to maintain it. You've also got to run it, and you need to update it as well.
(14:43) Say you have a team of three to eight people. The way I like to think about these things is not the annual rate but the cumulative rate over five years or so: how much you'll end up paying purely in salary to build your platform. Of course, this is one team, and if you remember scope creep, you're probably going to need more than three to eight people. And once you have more than three to eight people, you need some people to coordinate and manage them. So you multiply out toward multiple teams, and you really start to get to the point where there's quite a lot of payroll for building this platform. Which, for those people, is actually kind of great, I guess: they have something enjoyable to do. But it does change the understanding of "oh, we can just build it on our own." In contrast, here are some numbers I've collected over the years of what a very
(15:36) effective platform team looks like when it's running a platform. Use whatever ratio you want: the number of developers they support, the number of applications, whatever. These are the numbers of actual operations people who run the platform. They don't build it or anything; they just run it and add little features here and there. You can see you get some great efficiencies if you don't have a whole team building and maintaining the platform.
#4 Platform as a project
(15:36) Next is a lack of platform as a product. Instead, you think of it as platform as a project: you've got a deliverable, you deliver that thing, and then you're done.
(16:19) We took the requirements, we stood it up. What you see the people who are successful at platform teams do instead is realize this is a product they're building. It's something they're adding new features to. They're paying attention to customers, experimenting, testing things. We heard a bit of that in both previous talks: the agents experimenting, getting feedback about how you're mediating things, the feedback loop. That kind of thing is often left out by the teams building these platforms. I talk with people all the time who say, "I don't know, we built the Kubernetes cluster and the developers are still upset.
(16:54) That's what they wanted, that's what we gave them, and we were done." Instead, you see a lot of product management in place at these organizations. They'll literally have a product manager doing product management things. They understand: here's our customer, the developers using the platform, so why don't we talk with them and figure out what they need? And not only figure out what they need, but come up with a theory of how to do it, put the code in place, and then go back and ask them whether it solved their problem. If it did, that's great, and if not, you've got an opportunity for improvement.
(17:32) This is just one tool up here: a survey we used to use quite a bit. You send the survey out to the developers. If you're building a platform and you don't know what developers want, you can ask them. As a former application developer: priority number one is having a long lunch, number two is writing code, and number three is complaining. So if you send out a survey, they'll be happy to tell you what's going poorly. And then, my product management tip: put it in Excel, sort by descending order of complaints, and you've got what's called a backlog. Go in there, start fixing things, send the survey out again, and see if you addressed it. I've obviously incredibly simplified it, but you get the idea. And as one little dive into a specialized thing,
Your AI corner
(18:22) here's your AI corner. All of us have observed how AIs work. They're a different, interesting customer to think about, with their own behaviors and ways of operating. A normal human has some common sense, ethics and morality, and took the annual cybersecurity training and read the policy. And developers in general are like: we build the thing, we put it in a registry, we fire off a pipeline, we follow that stuff, we do all the things that let the platform deploy things on its own and follow policy. Agents don't really care about that. They're like, "I was told this application should be running, so I'm going to go figure out how to use the registry, I'm going to go over here." They'll run around everywhere if you don't constrain them. That's controllable, but things go crazy. If you remember back to the normies, all these thousands of people are running
(19:16) Claude Code or whatever on their own. In that case, things get even crazier. You don't have control over the agents running there: they come in, use whatever they want, and run all over the place in your infrastructure. You see this happening when you use it on your own, if you don't add a lot of, as they say, guardrails and things like that. It's a new type of customer to consider, someone you need to build around and think about.
#5 Retaining skilled people
(19:16) Next, the last few are more about people than robots.
(19:50) I see this over and over again: the difficulty of retaining skilled people. We can use Kubernetes as an example here. As you can maybe intuit, I love surveys, so here's a survey. The Cloud Native Computing Foundation has done a survey for a long time. They haven't done one this year; they just announced they're collecting questions,
(20:21) so maybe you should go answer it if you want to. You can see that in 2017, one of the top problems, as always with new technology, was lack of training: "I don't have the right people, the right skills." If you follow AI issues, what's one of the top things people blame for AI not paying off? "We just don't have enough training. People don't know how to do it." And you see that in the Kubernetes world too. In 2017, 40% of respondents were complaining that training was a big issue.
(20:56) And they had a great victory: down 4%, however many years later, in 2025. Still an issue. It's always an issue having the skills, because technology is difficult. A lot of people say people are difficult and technology is easy, but I would encourage you, as people who get paid a lot of money to work on technology: never say technology is easy. Not good. And you see that here too: it's always complicated. I would see this a lot. People would figure out how to build up Kubernetes, they'd build these great platforms, I'd be talking with them, and then I'd meet with them some months later and they suddenly had a new job somewhere, because they'd built up a very, very valuable set of skills. You'd see this over and over: difficulty retaining this talent. So you build your own platform,
(21:46) you solve all the difficult problems, you've trained up this group of people, and often they just walk out the door at some point. Now you don't have them, or their understanding of the platform. I'm sure they wrote fantastic documentation and lots of test cases, probably great; they left behind a bunch of .md files so your little robots can consume them and learn how to use it. But this becomes an issue over and over again: how do I not only get people who know how to do this, but retain them and keep them working here, so I can keep using the platform we built?
#6 Resume-driven development
(21:46) Which gets us to the next one, which is really just an aspect of that, but like I said, sometimes you've got to scratch things out to fit your talk title.
(22:32) What motivates that? Well, getting a better job does. But there's actually an academic study going over this phenomenon. I think only one, and you probably need more than one academic study to make something valid, but it's fun nonetheless. It goes over resume-driven development. This is more of a broader technology problem, but think about the cycle that happens. It's difficult to find people who have the skills you want, so you want to make the job attractive. Not only do we have a great culture, a bunch of free or low-priced coffee, fantastic facilities, things like that,
(23:14) but you're an operations person or a developer, you like to tinker: "we're using the best new technologies possible. We're not hiring you to come modernize our app or make sure our mainframes are running well." Although nowadays I often think that might be kind of fun, figuring out mainframe stuff. But anyways: "we're using whatever the new, interesting technologies are, hiring into this new role." So think of it as a person,
(23:44) a tech person, looking at the jobs out there. You see all these requirements for all these new technologies, so you think, "if I wanted a new job, I'd have to know this new technology." So you go back to work and you're like, "you know what we should do? We should use this new technology," because it would look really good on your resume. You don't say that part out loud, hopefully. But you end up in this cycle, as the paper goes over, with whatever the interesting new technology is: a loop that goes on and on, and you end up focusing on that. Why that's relevant for a platform is that, as many people have observed, mysteriously, we kind of keep rebuilding the same things over and over again, improving them a little bit. It's good to have this awareness: do we really need to rebuild this thing, or can we rebuild it slightly? What should we do here? Are we just...
#7 Keeping up with security and compliance
(24:33) And then there's keeping up with security and compliance. This is one of those things that's way out of most initial scopes. When you build your own platform, you think, "we need to support the applications, and it would be cool to have some global scaling out and scaling down," all the cool, fun stuff. But rarely are you thinking, "and then when the CRA comes out, or whatever new EU regulation comes out,
(25:20) where we're on the hook for security updates, or some other thing comes out, it's going to be really fun to implement that." It's not really on your roadmap to fit in some interesting compliance or governance that's coming down, which is a common thing that affects many people. Not to mention just patching things. If you track the CVEs that have been going on, I mean, it's not unexpected, but I think it's nice to see charts for these things we throw around as facts, because here they are.
(25:54) 2026 is almost over, thankfully, depending on your view of life, but you can see that this year it's been bonkers as far as the number of CVEs out there. Sure, these aren't all high-priority things, but you get the sense there's a lot out there, and you could spend a tremendous amount of your time just keeping up with this. Think about having built your own platform, and remember the credo: "not my mistake, now my problem." You've got all these layers that you're now in charge of keeping up to date. And then, to bring our fun AI friend back, there's another phenomenon. You've got the developers, who,
(26:45) I think by now, are smart enough to know they shouldn't just go to the internet, download things, and build software on top of them. Maybe there's some variation in that reality with developers, but they generally follow the procedures: we use the enterprise repos. But then you bring in those thousands, tens of thousands, of normie people, and they don't know anything I just said. They're like, "what I do is type in here, and my little robot goes out and downloads whatever it wants from wherever it wants and starts running it." Of course, you can do some desktop management to shut this down; there are all sorts of things you can try. But corralling all of that madness is another thing to think about when you're building your platform. And I think this is a motivation for thinking about all the customer types you have,
(27:43) including trying to get more of these AI workloads here. Just like you have the developers nominally following your protocols and your politeness, you want to somehow attract the AI, or the people using it, over to your stuff instead of doing whatever else they want out there.
Stop building your own platforms
(27:43) So with that: don't take my word for it. There are lots of great talks. You've probably seen Abby Bangser talk; she's great at talking about platforms nowadays,
(28:15) one of the best platform leaders out there. It really is worth thinking about. If you have someone who's getting excited about building their own platform, there are some things to consider before you go in there, and think more about how you can find a platform you could use instead. That way you can stop building the platform, go all the way back up, and start building apps, instead of consuming your time with that. And with that, thanks again for having me. You can find the slides and other things there if you want. Enjoy the rest of the evening.

