Luca Galante (00:00):
It's really about just becoming, I think, better system thinkers. I really think platform engineering can help with that. So from kind of like, hey, human is the loop and the human does everything, to human in the loop, human on the loop, human out of the loop. And basically really the human just becoming this sort of just constrained setter that really just describes what the system is and really just checks on the system and tweaks directionally how it's self-evolving. And really, I think in general, getting into a mindset of automating yourself to the next step is a good thing.

Nicky Pike (00:37):
This is [Dev]olution, bringing development back to speed, back to focus, back to freedom. I'm Nicky Pike. Okay, so everyone's talking about how AI is coming for the developers. You write the prompt and we watch code fall out of the sky. The humans were supposed to be optional. Here's the part that flipped on everybody. The same wave that was supposed to shrink the need for engineers just made one particular kind of engineer the most important person in the building. Because that jaw dropping demo, the one that took a weekend and looked like magic, getting it to survive day 100 in production is a different sport entirely. Not just does it hold up at scale, but was it built safely? Can it be governed? And when it goes wrong, how many people does it take down with it? And the people who get you across that gap didn't get smaller.

(01:23):
They got essential. So did AI prove the doubters right or did it just prove the exact opposite? Let's find out. My guest today is Luca Galante. He runs the largest platform engineering community on the planet. He hosts PlatformCon, and he has spent years watching real enterprises turn flashy demos into something that actually ships. If anybody can tell us why AI made platform engineers the center of gravity instead of shrinking them out of the picture, it's him. Luca, welcome to The [Dev]olution.

Luca Galante (01:51):
Thank you, Nicky. Thank you for having me. Excited to be chatting about these topics.

Nicky Pike (01:55):
Oh, this is always going to be a lot of fun, man. So go ahead. Take me back for a little bit. How did you end up at the center of the platform engineering world? I'm not talking about the title, I'm talking about the story. What was the moment that you realized this was the thing worth betting years of your life on?

Luca Galante (02:10):
So this actually comes out of Humanitech. Some people might be familiar with it. It was one of the original kind of platform engineering vendors in the space. We started it six, seven years ago at this point. The thing though is when we went out to market with a platform engineering solution, nobody had heard about platform engineering and nobody was really calling themselves a platform engineer. So you can imagine we had a bit of a problem trying to position the, really just frame the problem set that we were going after with our product. Especially our former CTO had lived through that at Google that he'd built internal platform there. We were seeing this kind of trend in the market. People were sort of gravitating towards building platforms, even though weren't really calling it that. There was clearly something where it's like, "Hey, this DevOps thing is great in theory, but it doesn't really serve scale to enterprise scale and enterprise grade.

(03:07):
And self-service, you build it, you run it. Great idea. But how do you actually do that when you're a thousand developers running on increasingly complex cloud hybrid setups, whatever?" And so we sort of just felt in the air. We haven't really come up with anything new, if you will. We really just created a space for people to come together for the first time and define what is the problems that you're trying to solve? What are the challenges? Share best practices. And then from there, starting to put together frameworks, reference architectures, things like minimum viable platform programs and really practical things that people could use. And that's ultimately what really formed the community. And it was actually quite an experience, especially at the beginning, I think, because you could just feel we hit a nerve. And so many people, especially the OGs that first came into the community that have been doing this thing for decades in some cases, they just didn't know what it was called.

(04:13):
They didn't have a name for it. And I think it was a big relief moment for a lot of them because they were like, "Ah, that's what I've been doing. I just didn't have a word for it." And so I think that was really cool. And then obviously it caught fire, no pun intended, with all the stuff that you and I were chatting beforehand. And then it just exploded. Obviously it became very mainstream. Now we have 300,000 plus people in the community. There's obviously a lot of also more junior folks that came in as wave two, wave three because they were like, "Huh, feels like I can make more money with this platform engineering thing than DevOps or something else, and it's like the hot new thing. And so let me jump on that." And then we'll talk about how this is evolving in AI and how I think it can stay the hot thing actually.

(04:57):
But yeah, and just to finish the piece of the story, we actually saw that the community grew so much. And the opportunity, I think, with platform engineering was so obvious in front of us that we actually moved on from the vendor. So we're at this point, we're completely separate. We've actually separated away from HuHumanitech about a year and a half, two years ago. And now we just run this as a media company with a very large community attached to it, if you will. We host courses, we certify people. We do things like PlatformCon and Platform Weekly, the things that you mentioned. And yeah, we're just very excited to just focus on platform engineering. And really the mission is making it as big of a deal as possible while, and this is really near and dear to my heart, retaining a one sort of platform that enables discourse for all the vendors and all the stakeholders of the ecosystem to agree on what makes the most sense.

(05:55):
And creating a sort of ecosystem level incentive to do that. Because I think what has created a lot of problems in things like DevOps and GitHub and all this keywords and hot trends before platform engineering is that as soon as something becomes a hot enough trend, you have all these vendors jumping on it and trying to just slightly tweak the definitions and the positioning to favor their products, which is a totally normal thing to do. But the problem is that if you compound it for enough vendors and enough people, it basically gets complete diluted and these things end up meaning everything and nothing. And that's really the thing that we're trying to avoid with platform engineering. And I'm actually pretty happy with how we've done that so far. I think there's a good alignment on what a platform is and what an internal developer platform is, and now what an agentic development platform is, which we're going to talk about and how this frameworks and standards are evolving.

Nicky Pike (06:53):
Yep. And as an old platform guy myself, I mean, I came to you guys and I think you struck the nail on the head there when you said you touched a nerve because you're right, you run a community that's north of what more, what'd you say, 300,000? It's more than a quarter million practitioners here. I mean, you host the biggest event in this space and you yourself, you write a newsletter that lands in 100,000 inboxes every week. So when we look at that and you look at everything that you talk about, people trying to tweak the definition, put vendor first, you're trying to keep it really level at the platform engineering practitioner step. When you step back from all this, Luca, what's the part about this job that really writes you up, that keeps you going?

Luca Galante (07:33):
I think the thing that we're probably going to double click on today, really how this discipline is evolving is fascinating to me because it's something that we started to really just frame the problems that we had seen on the field and that we were trying to solve. We did not think that this could actually be the way that you do AI in the enterprise, for example. And so it's just fascinating to me how a lot of these different threads have been converging in my both professional and personal life. I mean, the stuff that I was consuming, like reading on Twitter, now X, whatever, now it's all AI. And so many of these crazy people that have crazy audiences, crazy amount of capital, it's sort of like capitals of the industry, if you will. They're talking about all this products, how do you AI enterprise? I'm like, you're talking about platform engineering.

(08:26):
And so it's kind of the next level for me of what we had seen five or six years ago, which was like, hey, let's actually put a name on this thing. Now this thing has a name, has an established community, has established best practices, but it's still in the grand scheme of things, very niche. Very, very tiny. 300,000 people is very tiny. And now with AI touching millions, tens of millions of people, I think you have this next opportunity of educating a much bigger audience around, hey, this thing that you're kind of dancing around on X and like, oh, I wanted four deployed engineers doing that. Yeah, it's like services building platforms that actually let you go to your point of your intro from this impressive demo to something that's actually enterprise grade and scalable. That's called a platform and you need platform engineers for that.

(09:17):
And yeah, so that keeps us going for sure. And we also recently put out a book, Casper and I with, so my co-founder Casper and I, it's called Thinking in Platforms. And we announced it's actually not available yet, but it will be in a month or so on Amazon. What we've seen in platform engineering in the last 12, 18 months is really hitting this inflection point where it's moved beyond the traditional DevEx and infra focus and into security observability, obviously data, obviously AI. And so really taking over the entire IT organization that is converging on this unified platform layer. But it can even go beyond that. And I mean, when I say we are like a media company with a large community attached to it, it means we have a couple of engineers, but mostly we're also just like sales and marketing people, community people.

(10:08):
We are dogfooting platform engineering like there's no tomorrow. And so we are seeing how you can take the same principles and apply them even outside of IT, which again is actually I think quite inspiring because in an age where everybody's becoming this sort of citizen developer without actually being a developer, again, the platform that needs to standardize and automate all the baseline and support all these new use cases needs to be even better designed and more solid. And that's really the macro tailwind, if you will, that's blowing behind us and that keeps us going and that I think makes the opportunity in front of us very exciting.

Nicky Pike (10:49):
So I find that very interesting. You talk about since your separation from Humanitech, that most of your team now are media people. Your media, you're kind of doing the sales thing, but you're having them dog food platform engineering. What does that actually look like? I mean, why are you doing platform engineering with a team that's not engineers? How does that look?

Luca Galante (11:09):
Yeah. So what that looks, first of all, for me, is having a user-centric mindset. That's the thing that we've always preached. I think one of the hardest shifts, especially, I mean now I think it's a more established way of thinking, but five years ago, a lot of the people that we're talking to were used to this DevOps mindset of like, "Hey, I'm just setting up infrastructure. Maybe I'm teaching developers about it a little bit, then I move on. I remain a bottleneck in most cases. If they need something, they need to go through me, ticket ops, the whole shebang where it's not really scalable." And our big thing was like, "Hey, the better way to think about it is like, well, actually you're building an internal product for your internal customers or the application developers. And then all this memes, this universe of memes around product management best practices that developed over the last few decades all of a sudden are unlocked and applied to this.

(12:03):
And then you can use them as guidance and heuristics for how you're doing this and so on. And I think that concept is the main thing that we're bringing over for our team where it's like, hey, it doesn't matter that our users are not software engineers. But for example, we create a lot of content. And if you want to produce high quality content at scale, it's actually not that different than if you want to produce high quality code at scale and you actually want to deploy it across all these different channels and different formats and so on. And all these things can be reduced to templates and golden paths at the end of the day. And that thinking in itself is extremely helpful because when you are. Every time I meet people at events, they're like, oh my God, how do you do it? You write a newsletter and you have all this other things and so on.

(12:54):
Yeah, it's because it's all templated. It's templated. That doesn't mean that we don't have the human touch, but that's exactly. In fact, we automate and standardize a lot more than we use AI actually. But the point is that baseline platform of automation and standardization actually allows us to use our humans a lot better so that they can focus on the things that matter. In the case of software engineers that is writing features as opposed to getting lost in Yamo configuration files. In our case, it's like write a good content piece or a good social media post or really spend an extra time editing the video, recording the video and so on, as opposed to how do I think about this BI dashboard that tells me how good the post is actually performing? That's all taken care of. It's very visible. It's actually not because I was having a cold this morning.

(13:50):
We have a terrible BI setup that doesn't work, but that's an example of something that we need to clean up and treat as an internal product and we are. And the great thing I think that also you ask what keeps us going, I think that is so satisfying as well. When you can really dog food the thing that you're preaching and you just see compounding. Because the beautiful thing about products is that they compound. They're not this ephemeral thing because otherwise, or you organize events, you do newsletters, you do content pieces, you do webinars, you do all these things. I think if you don't treat them as products, it can feel very ephemeral and very like, okay, now I'm doing this. Tomorrow I'm doing that. The next day I'm doing that. And it's like, I have nothing to show for it. And it doesn't feel like you're necessarily improving every time.

(14:36):
Whereas if you treat them as products and you treat the system that support those things as products as well, you just see this thing compounding. And it's very satisfying in my opinion.

Nicky Pike (14:46):
You just wrapped up platform engineering in the perfect DevOps initiative. It's how do we standardize? How do we templatize to make the right path the easy path? That takes a lot of load off of the developers or in your case, the marketing, the content creators, because they don't have to think about all these different steps. The platform takes care of that for them and it moves things along. That is the definition of platform engineering, at least how I think about it.

Luca Galante (15:08):
Exactly. And this is, by the way, the need for this is being turbocharged by AI. Because now I have 20, 30 people on the team that all want to use AI like crazy. And in fact, we incentivize that. We have AI demo days every month and everybody can show what they built and whatever. But again, it's like what we were saying at the beginning. You go from something that's an impressive little demo to like, okay, how do I now roll that thing out that we built for a specific design flow in a specific part of the business to the entire thing? Because actually that can be a standard now that is just applied to everybody. And that's where platform engineering comes into play. So now we have an internal platform team of three people that basically take these things every time they're upvoted in these competitions and they're like, okay, this is actually something really cool that we've done in this little corner of the business.

(16:04):
Let's actually turn that into a standard. You can't ask the individual contributor to do that, A, because they don't have the context across all the other verticals. And B, because they might not be technical enough. They had a good idea to solve their problem. And again, I think this is what the AIs that we have today, they're great at that. They're great at helping you frame a problem and tackle that. They're not, I think, great at like, okay, well now how do you take this and you really standardize across the different things? And frankly, make it deterministic. Because so many times you've realized, okay, now I solved this thing. You can encode it into a Claude skill, for example, and that's okay.

(16:43):
But Claude skills, we've all used them at this point. It's like they rebuild themselves every time. And then even if something is encoded, they still somehow sometimes go off path and then they make mistakes and you're like, wait, we went over this before. Why are you doing it this way now? Whereas they can be great way of experimenting and building something in a way that you would've never been able to do before if you weren't technical because you just couldn't glue together the different tools in the workflow and actually just, hey, try this. Now you can do that, but then okay, now that we've defined that and that's a cool thing, okay, how do we scale that? And so we do a lot of that stuff. And the enterprise teams that I talk to are seeing this 10 times more. Because you have a hundred thousand employees and whereas before we were just focusing on your 5,000 developers.

(17:41):
Now, again, everybody's doing this. And one of the key trends that we see on the field is this crazy amount of inbound requests coming into the platform team actually that are asking them for help. It's like, hey guys, we've built this thing in marketing, we've built this thing in legal, we've built this thing in wherever. And now it's the time where it's starting to be serious and we want to scale it to more teams or whatever, and we have no idea what we're doing because we're not actually software engineers. We're not actually large-scale system builders and we need help with that. And that's again, where I believe platform engineers can play this pivotal role in this transition to what I would define as the agentic enterprise and really be the ones that build all of the support systems for new use cases and old teams in the enterprise.

(18:33):
And this is by the way, why a couple of weeks ago at PlatformCon, we announced AgenticCon, which is our sort of test balloon to see, hey, can we actually create a new space in the market and in the community to bring together platform, not just platform engineers, but platform engineers, which is really what platformengineering.org and PlatformCon and all these places have been for and will remain to be for, but also platform engineers with other domain experts and other teams in the enterprise to really define what are these new use cases that our baseline platforms need to support.

Nicky Pike (19:08):
Yep. Well, and I think that leads us right into what the challenge is on the table. And here it is. When we look at DORA's latest research, it says that platform adoption has gone universal. 90% of organizations are now running an internal developer platform, and 76% of those have a dedicated platform team. So I think, Luca, the argument's over. Platforms have won, except winning the argument and knowing what to do with the win are two very different things. Most of the companies in that 90%, they stood up a platform because the board had AI FOMO or FOMO about getting their code out, not because they know what it's actually for. And I think that's the key thing here is what it's for isn't just to ship faster. It's the thing that decides whether all of this AI that we're bringing in runs safely and whether anybody can actually govern it.

(19:55):
So it's also the thing that I think decides when an agent goes off the rail, whether that agent is going to only take down its own little corner or if it's going to take down the whole building. So I kind of want to start there. Platform's one. Let's agree on that. But how many of those companies actually understand what they committed to and how many are just checking a box on the platform itself?

Luca Galante (20:15):
Yeah, that's a multimillion dollar question, I guess. And first of all, I would like to, I guess, just pause for a second and appreciate the platforms one because that was not a given I think at all. I remember when three years ago or something, Gartner put out this forecast and was like, oh, I don't remember the exact numbers, but something like 60%, 70% of enterprise organizations will have some sort of platform team and platform initiative in place by 2026 or something. And I remember -

Nicky Pike (20:46):
It was 86%. I know what you're talking about. It was 86%. 86%,

Luca Galante (20:50):
Correct.

Nicky Pike (20:50):
Thank

Luca Galante (20:50):
You.

Nicky Pike (20:51):
Yeah. Of enterprises that are going to do that.

Luca Galante (20:53):
Yeah. And I was like, that's crazy. Even us at the time, I think it was back in 2022, 2023. And I was like, that feels very optimistic. And then to your point, the DORA report came out last year and it was like 90 plus percent of the people we surveyed have platforms in place today. That I think is I would say the proof of compounding when even the insiders, if you will, their rosest expectations are beaten because this thing just takes over and goes vertical. And so just I think cool to see that that's happened. However, I would also say that if you think about how many people.

(21:37):
I feel like there is a bias in who DORA surveys. You know what I mean? Is it actually 90% of all existing enterprises? No way. It's actually, and this is why I say it when I talk about 300,000 people, it's still a small niche. It still is. And so I think there's still long ways to go because if we just focus on your question, you can split the world then in basically two groups, the people that already have platforms in place. So now how are they going to go into AI? And then everyone else, which is still the majority, I would say, that is not in our immediate one, two, three concentric circles that's still DORA affected and so on. And so how are they going to do it? And so I think for the people that have a platform, I think obviously they have a huge head start because it's what we're saying.

(22:24):
You can literally take the same principles and apply them over. Now, it's not that straightforward because again, I think A, the pace is putting a lot of pressure on them. B, I think interestingly, maybe they've started now to win the argument of like, okay, hey, platform engineering really makes sense and we need it and blah, blah, blah. But now that all of a sudden the entire organization, even beyond IT is looking at this AI thing and what do we do with that and so on. It's much harder, I think, because the total addressable market that you're selling into internally now 10Xed. And so it's still a whole other order of magnitude that you need to go after. So they definitely have an advantage, but it's not straightforward, I would say, for everyone else. This is what I'm saying. I think it's a big opportunity for us as a community and as a team to really just evangelize and tell them, "Hey, this thing that you're dancing around, it already exists.

(23:20):
It's co-platform engineering. There's already 300,000 of us in the world. And frankly, there should probably be 30 million of us because that's what's needed to really drive this next kind of leg up and this next transformation." And I also just think in general, everyone has to become, I think, more of a platform engineer/system thinker, system builder. Because even on the individual contributor level and you have a bunch of agents running around for you, you just need to build some sort of platform and system for yourself to standardize and automate across them. And so yeah, I think there is a really big opportunity, but I still think that 95% of the world is clueless about platform engineering. So it's going to be really hard, I think, to. They will basically have to go through the same pains and the same challenges that we have gone through in the last decade basically.

(24:16):
And hopefully we can get to them quickly enough that maybe we can shave some of that painful time off and they can get to some sort of solution of starting applying these principles. And by the way, you might listen to this and say, okay, this is the platform engineering guy talking. And of course it's mega bias because he's been talking about platform engineering for the last five years and now sees this new AI thing through this platform engineering lens and of course. I actually would argue, and I'm the first one to doubt myself because I was like, huh, it seems like a little bit too easy that it's like the thing that I've been saying that I've been preaching for the last five years turns out to be the thing that you actually need to for the next massive wave of technological change. But I actually think if you zoom out enough, platform engineering is really rooted in what I think is ultimately one of the core drivers and engines of positive change and development in the last 300 years since capitalism basically and delightment and whatever, which is division of labor, which is how we think about factories and really the industrialization.

(25:29):
Since the beginning of the industrialization to now, most industries have gone through this progressive process of specificization and assembly line thinking. And this is what got us mass production of very complex things like vehicles and cars. And

(25:50):
Now I'm building a new house. So I think about platform engineering every time with Ikea shit and everything. It's all this stuff. And in software engineering, and I would say broadly knowledge work as well. Because they're still in the grand scheme of things, I would say, nascent industries. I mean, software engineering has been around for whatever, maybe a 10th to a fifth of much more established industries. Some of these concepts are not that well established. And in fact, I've argued in previous blog posts and podcasts and so on that if you look at how we were building software 10, 15 years ago, it was very artisanal as an approach still and still is today in a lot of cases. And so we're still in this transition. This is really what platform engineering ultimately is, is moving dev shops essentially from artisanal shops to factory floors.

(26:49):
They're actually outputting stuff at speed. And obviously I think one of the important misconceptions to immediately stop there is that doesn't mean you as a software engineer are just a kind of dumb assembly line robot that's just doing things. It's actually, again, it's like we are taking all the shitty repetitive stuff away so that you can shine as a human and as a creative knowledge worker and not getting bogged down in all this implementation details and so on. And I think the same thing applies to broadly other types of knowledge workers. And we've given the examples of content creation and marketing and all these things. They all work in a very similar way, I think. And AI is really just turbocharging the need for us thinking about these things in terms of golden paths. They're ultimately tracing back to assembly lines in the Ford era.

(27:41):
And so I think you actually have this huge lindy effect of platform engineering. Even though the term platform engineering has been around for five or six years, it actually is rooted in a multi-decade, multicentury tradition in my opinion, which is what I believe justifies us betting on it as the thing that can actually help us in driving AI adoption and AI deployments in the enterprise. That was a bit of a engine, but.

Nicky Pike (28:10):
No, I love everything you said, but I'm going to push back on you a little bit because we talked about, hey, the people that already have platforms. So here's where we're at. Platform's one. 90% of companies are running one. And the guy who runs the biggest platform community on the planet just told you the quiet part out loud. Most of them stood one up because the board panicked, not because anybody knew what it was for. And that's the part that should stick with you because the people who actually have to make this AI survive in production, half of them weren't even in the room when the company decided what to buy. They just got handed a pile of agents and told, "Go make it safe." When we come back, Luca could get specific about how you fix that, what the platform actually looks like when everybody in the building is suddenly a developer.

(28:52):
Where you put the guardrail so one bad agent takes down its own corner instead of the whole thing and why he thinks the fix might be a job that doesn't even have a name yet. Stay with us. But when we look at platforms, AI is changing the definition of what that platform should be. I mean, it's a rethink of the platform because like you said, platforms were traditionally built for almost what is now a niche community. It was built for software engineers. But with citizen development, with everything that's going on, we're seeing a huge influx of source code. We're seeing a huge influx of applications that are coming into these platforms and they act completely differently than a platform that was built for human scale. Now we're talking machine scale. And that I think is going to change. I mean, even if you have an established platform team, you have to rethink your platforms on how you're going to keep up with this influx.

(29:38):
And that's one of the parts that kind of scares me is it feels a little unfair because these platform engineerings or the platform engineers are the ones that have to make all this stuff work in production. But half the time they're not even in the room when the company's deciding what AI are we going to bring in, what tools are we going to bring in? They bring this stuff in and then the platform engineers just get handed this pile of agents. They get handed L OM access and they're told to go make it safe. I mean, how real do you think that that platform evolution's going to take and what does it do to the people that have to carry the weight of that?

Luca Galante (30:09):
It's a great point and I totally agree. I think one of the key things about platform engineering is you're building a product and a product is constantly evolving. And obviously that evolution is driven by your user feedback. And to your point, the user set is changing. That itself is evolving.

Nicky Pike (30:27):
Growing exponentially, right?

Luca Galante (30:28):
Exponentially, because you add agents now and it's like 10, 100X of the users of the platforms essentially. I think the good news is the same principles apply like we talked about. But I think everything is just turbocharged to move a lot faster, which will break things to your point. It will, I think, break some of the existing sociotechnical boundaries of existing organization and platform teams. Because to your point, you can't have a platform team that was let's say 10 people supporting an organization of a thousand engineers. That's already a good ratio. And now all of a sudden it's like, well, actually you're also supporting all the other 8,000 employees.That's not going to work. And so that's why we're creating things like AgenticCon for people to come together and think about how does this need to evolve even from an org chart standpoint? And my current feeling is, and we've published this reference architectures.

(31:27):
Can I share my screen? Does that -

Nicky Pike (31:30):
Yeah. Yeah.

Luca Galante (31:31):
Let's

Nicky Pike (31:31):
See if it's open here.

Luca Galante (31:33):
So this is how we are thinking about platforms evolving in the agentic era. The thing that we had been talking about for years in the platform engineering community is this reference architectures for how do you think about internal developer platforms? And this is the different sort of planes that are there and so on. Now that thing here basically just becomes the tooling layer on top that is consumed by, to your point, both human and agentic users. You then add two more layers now, path specifications. So these are things like both probabilistic. These are things like skills, for example, that we talked about earlier. The good old deterministic things like your CICD and so on. And then a lot of people, an X, for example, call loop engineering is really kind of like a hybrid between probabilistic and deterministic kind of self-improving. And then you have the infrastructure that all this stuff is running on.

(32:26):
Obviously there's a lot of hype around agentic engineering. There's a governance element, and then there's the actual infra that this stuff runs on. So this is how we think about it. Now, if you think about IT organizations, platform engineers, I believe, will be responsible for the entire stack. If you think about the rest of the organization, I think platform engineers will be responsible for this because this turns out is the same thing across all of them. You're hosting, regardless of whether you're using this for development, marketing, sales, legal, whatever, you're still hosting in the same place and you're using the same underlying models regardless of how you architect that and how much governance you have and how much self-host that you have or how much of a pass and you give all your control to Anthropic and OpenAI. Those are all architectural design considerations, but that thing is going to support everything.

(33:25):
And so that I believe is what platform engineers should focus on. And then the question is, how does this thing support not only the thing that you see here, which is the three layers for agentic development platforms, but also agentic marketing platforms, agentic finance platforms and so on? And you essentially swap the tooling and the path layers, but they will sit on the same thing. And so obviously I think the key kind of where the rubber meets the road, so to say, the friction is going to happen in between these two things. Because you're going to have platform engineers from the bottom coming up and meeting the domain and specific teams here. They're like, "Hey, I built this skill that's consuming this tooling, but how does this now become actually scalable and rely on the same system that are the standards across the organization?" And that's the conversation that we need to have.

(34:17):
And I think that will also potentially give birth to new roles. Or one of the key roles that we've always talked about in the community is platform product managers, because they're really the ones keeping the entire ship together and gluing the different perspectives of the users, the infra people, the security team, the governance and so on. And so they're the ones sitting in the middle. And so you're going to have to have platform product managers that probably come from the individual domains that kind of bridge that gap. I don't know yet, up to TBD. And I'm very excited to spend the time with the market and the community to define this. But I think that's how we are thinking about it right now. And I think how the platform team needs to evolve to essentially add yet another concentric circle around it of product thinkers that support different new types of users across different verticals, both humans and agents.

(35:18):
I actually don't think there is. I think once you define it well for humans, I don't think there's going to be, and it's well-designed in both probabilistic, deterministic and have the right guardrails. Ultimately, you can take the guardrails. Gregor Ope often talks about this in terms of this paved road example. Hey, if you have a road that's all bumpy and has all this potholes and so on, it's really hard to drive on it. If you pave it really well and you have really good asphalt and really good guardrails, then you can speed 200 miles an hour and you're fine. Once you have that, whether you have one car or five cars, it's just a question of how many lanes you add, but the foundation and the design is there. But I think the hard bit is where do we put those guardrails and what's the foundation?

(36:09):
And I think that's the exciting bit that we need to figure out.

Nicky Pike (36:13):
Yep. And so for those that are listening and maybe not watching, we'll put a link up to this in the show notes on how you can go view this because what you're kind of describing here, Luca, is this three stack way of agentic development, what the agent development platform looks like. We got the tooling on top, the paved paths in the middle, and the agentic infrastructure underneath. And that sounds great, but here's the question I want to put for you. Again, we're going back to platforms were usually built for people that actually had an idea of what they were doing. They understood Git, they understood how to bring dependencies and things of that nature. They knew what functional loops were. But to the point that we've all been talking about, we're now bringing in the citizen developers. And I think that complicates things because now we've got near infinite variability.

(36:54):
Not only do we have people coming in using AI to write software that have no or very little concept of what software development looks like, what right looks like, but they're using AI, which AI is non-deterministic. The same individual developer or the same builder could go and ask AI to do something, and they'll do it three different ways if they do it three different times. What does the platform look like? I mean, how do we move from that? We've got developers where we kind of know the direction they're going to go to. Now we've kind of created this multiverse, if you will, of potential optionality of what developers or builders could do with AI and non-traditional technical people. How do you build those guardrails when you can't really determine which direction they may go?

Luca Galante (37:39):
I guess what was trying to define with this sort of product thinking in the middle. I think that's what needs to happen. I don't think we can expect that everybody's going to become a platform engineer. That's not realistic. But I think what we need is somebody in between the platform, the technical platform team that we traditionally define platform team. And all these new users, all these new citizen developers, and this person in between or team in between needs to think like a platform team as well. Even though maybe they're not the ones actually maintaining and building the underlying infrastructure for it. They need to be the ones thinking in golden paths, for example. Because if we go back to close to home, the example that I was giving earlier about content creators, it's not necessarily that all my writers, both internal or external people that I collaborate with have to dog food platform engineering and fully understand.

(38:35):
I mean, in our case specifically, maybe yes, because we write about platform engineering. But if I was writing recipes for kitchen or any other type of content, whatever, the writer can just focus on the kitchen recipes. But there needs to be somebody in between that thinks about like, "Hey, okay, the way we write this recipe is always the same." So that can be amplitized into one thing. So really just bringing that thinking. And in my experience, you can have similar ratios to what we've had until now in IT organizations where you have this one to 10 platform engineer to user type of ratio. I mean, it varies widely. Sometimes it goes one to three, one to five, to one to a hundred in some cases. But when you actually think about. But that's platform engineers that actually build the thing. When you think about the product manager, sometimes you can take one or two product manager for literally thousands of users if they're doing their job well to be able to.

(39:34):
Because at the end of the day, you look at these golden paths in IT orgs, for example, things like PR reviews, you can list them. And yeah, you get to a list of what are the actual. If we think about the famous image of the university campus and how people are walking in life forming all these new paths, sure, there are all these new paths that form

(39:58):
That you didn't expect. They're outside of the actual paved ones. But after a while, it's the same 20. It's not that people actually really like to step on grass all the time. And so the same thing is here. When you actually really start drilling down and you start looking at this content team and that content team is not that the content changes, but the actual paths are pretty similar. And so you can start templatizing the stuff, and we actually

(40:24):
Are starting to do some of this work. Again, we're still focusing on IT organizations and agentic development platforms as our main use case. But we see it internally again, you can templatize the way you create content or the way you do certain marketing campaigns. And there's maybe 10 different ways of doing it, but those 10 ways I can guarantee are very, very similar in how all the other media companies are doing it or even people in completely other industries. And so I think it's about having this few enlightened people that are thinking in platform engineering terms and are able to essentially translate the needs of the users and all these new season developers that are tapping away or whispering away with their Claude and creating all this new stuff into like, okay, but what are the reusable actual templates and golden paths that we can standardize and automate in a deterministic way, to your point, across that specific teams that then is supported by the original platform engineering team that is supporting the infrastructure anyway for the IT organization.

(41:29):
And I think over time, maybe through things like what I hope AgenticCon becomes, also just better known templates, even in other industries where they're like, "Yeah, I know that there is a golden path or whatever they're going to call it, like a blueprint, a template for how I run ads across multiple things in a half deterministic, half probabilistic way. But there are defined and best practice ways to think about it.

Nicky Pike (41:59):
So from my analogy portion of this, what I'm hearing you say is that the platform becomes like a rail switching station. If we think about developers starting out from anywhere, they get into a station, but we know the destination that they're going to, then at this point, the platform should be the rail switching station. We'll make sure no matter where you started, that you get on the right track to get you the destination, which is going to be that production. Do you think that fits? Is that kind of what you're saying here?

Luca Galante (42:24):
Exactly. That fits perfectly. And I think we can have different type of rails for different types of users. And I think that really the tricky bit is going to be figure out how do you have multiple people working together with the platform team to define what these rails are? But this compounds.

(42:43):
I think we can have library of these paths that are available for everybody to consume easily or at least to get inspiration for, again, how do you think about industrializing your specific bit of the world? And the other part of course is the switches need to be constantly changing and evolving to adapt to new requests. And that's where the feedback loop between platform engineers and application developers was how tight that loop is, is always the best indicator in my opinion of how well the platform initiative is going to do. That's even more true now between platform engineers and platform product managers and everyone else. Because everyone else is also running a lot faster and you have agents and you have all these new things. And so you just really need to listen and really need to iterate quickly.

Nicky Pike (43:41):
Yep. I agree with that. Now, one of the things, since we're talking about developers, one of the things that I heard you talk about was that people need to stop being developers who just write code and they should look at starting to be orchestrators or constraint setter. Now I think that's a real career shift for a lot of folks that may be listening. What do you think someone should actually do differently on say a Tuesday to actually make that move now that we've got AI in the picture?

Luca Galante (44:06):
It's really about just becoming, I think, better system thinkers. And again, I think I'm biased of course, but I really think platform engineering can help with that. I mean, we're also now in Platform Engineers University putting out new courses that really help you move alongside this evolution of what we call, for example, the four levels of agentic development. So from kind of like, hey, human is the loop and the human does everything, to human in the loop, human on the loop, human out of the loop. And basically really the human just becoming this sort of just constrained setter that really just describes what the system is and really just checks on the system and tweaks directionally how it's self-evolving. And this might sound like science fiction and crazy, but if you think about very small, very defined in scope things, I already feel like in some cases I'm in a level three, maybe pushing level four of something that's very, very defined, very simple.

(45:14):
But where you have agents that clearly are defining scope or reaching out to people or doing these things, are doing blah, blah, and entire thing is running automatically. And it's just hosted even on the cloud.You're not even starting those actions. And so I think the ability of breaking down complex and very intricate tasks and combination of tasks into just simple and simple things that then you can standardize through golden pad thinking and then automate over time. And really, I think in general, getting into a mindset of automating yourself to the next step is a good thing. I think a lot of people are still very afraid of like, "Oh my God, I'm going to automate myself out of the job." And it's just never the case. I'm a huge believer in Jevons paradox. And you're already seeing this idea of the companies investing the most in AI are also the ones that are hiring the fastest.

(46:16):
And obviously there's a bunch of confounding factors there potentially because it's kind of self-fulfilling prophecy that if you're investing a lot in AI, you're probably somebody that's advanced, is doing well, has a lot of easy mind, so you're also hiring the fastest. But I think there is something there where we've seen it every time. Every time there is a technological shift and productivity jumps by an order of magnitude, you're actually getting more jobs, you're getting more opportunity. And the same thing I think I see again, I see internally, it can be I think an initial instinct of saying, I can just automate this whole thing away and then I actually don't need these people anymore. But actually the moment you actually start doing this, you're like, actually, I want more people now because those people are more productive now and I can plug in more people and get more value out of the whole system.

(47:07):
And so I think people really just need to embrace this, both managers and executives as well as individual contributors on the different layers they operate on.

Nicky Pike (47:16):
All right. So Luca, I want to bring back up, you brought up AgenticCon and it was this idea that we need to get platform engineers sitting in with all the citizen developers, the sales, the marketing, the ops folks who are now starting to build their own applications. Why do you think this room needs to exist? I mean, what's going to break if the platform teams just keep their heads down and work on their platform and they never have this conversation?

Luca Galante (47:37):
Yeah. Well, I think the risk with that is this rosy picture that we just painted of platform engineers becoming this pivotal role in us transitioning to the Agentic enterprise and everything. Then it's not true anymore. Because I think if you just stick to IT organizations, I mean, I think there's still going to be a lot of value there for the foreseeable future, but I just really, we're seeing it. We have all this inbound requests already today to the platform teams because who else should respond to this inbound request from all

Nicky Pike (48:09):
These

Luca Galante (48:09):
Other teams in the enterprise? All these people, they're already hitting the limits and somebody's got to figure out where this whole thing runs and what's the best practice and how do we think about these things? And I don't think there's even another candidate. I mean, I guess you could say, "Hey, if platform engineers are not going to step up to the challenge, you're going to have some new role, AI engineer, AI, whatever that basically in the end does platform engineering applied to all the other things. And then platform engineering is that essentially. You could argue that there'd be an outcome. But I feel like we've reinvented the wheel enough. So maybe we can just really take this amazing community that we have that I think is still young enough, that still has a lot of energy, a lot of passion, a lot of momentum, and really drive it to the rest of the enterprise organization.

(49:01):
And that's what we're going to try to do. So we'll go for it.

Nicky Pike (49:04):
All right. Well, now we're going to get into the rapid fire portion of this. So I'm going to ask you a bunch of questions. I don't want you to think too hard about them. Just say what comes off your mind. This is just something to see where your mind's actually going. All right, so one word. Is platform engineer going to still be a job title in five years or do you think it's going to get renamed? Still

Luca Galante (49:22):
A job title.

Nicky Pike (49:23):
Still a job title. All right. The demo or the day 100 production system? Which one of these gets applause that it really doesn't deserve? Demo. The demo? All right. The homegrown platform your team spent a year building or a commercial one that you could have bought in a week. Which one do you think teams get a little bit too precious about and why? I think

Luca Galante (49:40):
They get too excited about the latter. It's funny, I was having this debate this week literally where five years ago we were always talking about PaaS versus IDPs. And we were always saying, "Hey, if it's an internal developer platform, you can't buy it.

Nicky Pike (49:57):
You can

Luca Galante (49:57):
Build it. If you can buy, it's called PaaS." And I think we are now basically going through another version of the same debate, which is like, "Oh, I'm a CTO and I've just enabled enterprise licensing for Anthropic, and so my job is done." And obviously I think it's interesting because you're seeing the only ones really that are incentivized at this point in the market are basically OpenAI and Anthropic because they want to grow into the PaaS thatdoes everything for you. And

(50:25):
Maybe on the backend, by the way, even steals your data and just spins up a competitor against you. But everyone else from the chips makers, Nvidia, AMD, OpenStack to the application layer, they are incentivized to actually keep this an open field. And this is why I think there's so much interest now in self-hosting and self-building and so on. And I think that's what we've seen enterprises want. So I think people are getting a little bit too excited about the PaaS thing. It's a quick win, but in our past enterprise experience doesn't really scale. In the end, you need control of your data, of your destiny, and you need to put in some work for that.

Nicky Pike (51:04):
Yeah, I find it very interesting because I agree with you. We've now got this technology talked about science fiction. I don't think either one of us two, two and a half years ago would've seen where we would've went with this, but it's bringing us right back around. It's like cloud all over again. Data sovereignty, now we've got AI sovereignty. I think we're going to see this push back to self-hosted in my opinion, because we're now employing agents that we can't really predict what they're going to do. So how do we put guardrails around it? The only way that you can really do that I think is self-hosting. All right, next question. You said that you bet on Platform Engineer because it's part of the Lindy effect, right? It's basically factory thinking that's carried us for 300 years. So finish this sentence. The thing that will still be true in 10 years is what?

Luca Galante (51:45):
Is if you're not thinking about your internal systems as products, you will be eaten up by competition.

Nicky Pike (51:54):
Ah, that's a good one. All right. And we're going to put a link to PlatformCon in the show notes on this one, but what's the best talk you saw at PlatformCon this year that wasn't yours, Luca?

Luca Galante (52:04):
Well, I will have to give it up to Kelsey. I was literally just emailing with him before. His talk went mega viral. He gave his talk on zero trust architecture. Frankly, I think a very great sobering talk. Because again, it's kind of like what we were just saying now with his passwords. It's kind of like, Hey guys, we've seen this before. We've seen this with cloud, we've seen it with this mobile. The same principles apply. Let's not go all crazy and think that it's a completely new thing. It's not. And it went crazy viral. It has something like 40, 50,000 views ever since we published the recording of the talk. And so that's actually amazing because one of the things that we always try to do with PlatformCon is keep all the content available for everybody. Obviously there's a ticket price to come to the event, but we record all the main stage talk and then make them available.

(52:53):
And the fact that 60,000 people or whatever have watched it is pretty cool.

Nicky Pike (52:58):
Yep. We'll get a link to PlatformCon and we'll get that specific one. I may reach out to you, Luca, make sure we get a link to that specific talk. We'll put that in the show notes as well. All right, here's the most important one. This is the one that people are really asking about. Gelato or espresso, which improves a bad engineering day the most?

Luca Galante (53:16):
Hey, how about Affogato? You know what it is? I

Nicky Pike (53:21):
Don't.

Luca Galante (53:22):
In the espresso.

Nicky Pike (53:23):
Oh, it's both. So you're combining them. I don't know. That may be cheating, Luca. But hey, if it works, it works, right?

Luca Galante (53:30):
Yeah. Yeah. I mean, it's funny, I think I've said this before, but I'm an Italian who didn't used to drink coffee until a year ago. And now I have my full barista set up, but I'm trying to platform engineer my way into coffee and I'm totally obsessed. And it's my first summer as a coffee drinker. So I'm discovering actually frozen coffee and all these things.

Nicky Pike (53:56):
Oh, that's crazy because there's a lot of veterans that are watching this that are going to go nuts right now. I'm not a coffee drinker either, even though you see me bringing my cup up. But I discovered, if you heard of it, it's called Creole Brew. It's chocolate that's brewed like coffee. So it's cacao beans, it's brewed like coffee. So you don't get the caffeine. They've got Theobromine. It gives you the same thing, but I drink four or five cups of that a day now, but still don't like coffee. And

Luca Galante (54:22):
It's like cocoa powder basically straight in your veins. Yeah.

Nicky Pike (54:28):
They take the cocoa beans, they grind them up just like coffee, you brew it just like coffee, but you get all those benefits of cacao powder and chocolate. So it tastes like a watered down hot chocolate. It's really good.

Luca Galante (54:40):
That's cool, man. I didn't know about

Nicky Pike (54:41):
This.

Luca Galante (54:42):
I'll check it out. I'll check it out. I'll

Nicky Pike (54:43):
Have to send you a link. All right, let's get to the predictions. I need you to put a number on this. We've got all the platform teams racing to stand something up this year. What percentage actually builds something that survives day 100? And what do you think happens to the rest?

Luca Galante (54:56):
I think it's going to be this year it's going to be an extremely low percentage. I think it's like 5% that's going to survive. I think there's still too much experimentation. People are still all over the place. They're freaking out. I think platform engineers still need to understand that, hey, this positive message that we're trying to give them like, "Hey, you can really be the most important person or one of the important people in the enterprise." And I still think they're in the process of digesting that. And we'll see, I think, some fruits next year. A lot of the work that we're doing now, the reference architecture is AgenticCon, all this new stuff I think has to percolate a little bit longer. I would expect it though to jump, let's say five to 30% or something next year.

Nicky Pike (55:41):
Yep, I agree. The rate of change is hard to keep up with, man. It really is. Just when we start to think we're getting a handle on things, new capabilities, new ideas come out, it's hard for us to keep up. So I completely agree with that. Last, no sugarcoating this. So everybody in the enterprise can now build software. AI has made build software very cheap. It's made it be easy. Five years from now, is this going to be the best thing that's ever happened to platform teams or is this going to be the thing that buries them?

Luca Galante (56:07):
Yeah, either/or. I think there's definitely not an in between. That's what I will say. I hope, like I was saying, that we can shift gears into supporting everybody. And I think this would be an amazing win-win for organizations and users first and foremost, and then platform engineers themselves. But if we're not going to do it, we're not going to be around in five years. So we'll see.

Nicky Pike (56:32):
I don't know, man. We'll have to talk again. Well, me and you talk all the time anyway, but we'll have to talk again because I still believe platforms are going to be the way forward. I don't care what the technology is. So I'll go on record to say, do I think it'll bury them? I think it will in the short time, but we're going to figure this stuff out. We always do. You've got a great community that helps each other out on this. And I think with your community and everybody else that's looking at this, platforms are still going to be a thing and it's going to be what makes it all safe for us.

Luca Galante (57:00):
Awesome. I hope so.

Nicky Pike (57:02):
Yep. All right, buddy. Well, you've spent years betting your working life on the idea that platform is what wins. It's that horizontal, it's the modular, and it's something that's going to outlast whatever tool happens to be hot this quarter. You've watched this discipline get renamed and doubted, and now you're watching AI show up and prove it more right, not less. After everything that you've seen this year and in years past, what does it mean to you, Luca, to be a coder?

Luca Galante (57:27):
Right now, I think we are in this privileged position to hopefully help large organizations and a lot of people on this journey on adopting AI and really getting value out of it. And I wouldn't have it in and out of way, frankly. So I think the team and I, we're super excited to be here and it means a lot. It really does.

Nicky Pike (57:48):
You're doing something right, Luca. You got a community of over 300,000 people. People are paying attention to what you guys put out and how you're looking at enterprise and platform engineering. So you're doing something right. Keep it up. Any last parting words before we cut off? Go sign

Luca Galante (58:03):
Up for PlatformCon and AgenticCon in San Francisco. We never done anything in San Francisco. We're super excited to bring it there for the first time. And the combination, it's going to be like a two-day co-located event. So PlatformCon, our flagship on day one, and then this new experiment that's AgenticCon on day two. I'm really curious to see how it turns out. And for anybody in the area, we'd love to have you.

Nicky Pike (58:27):
Yep. Looking forward to being there. And like I said, we'll see where this goes. And Luca, thank you for being on the show. This won't be the last time we talked, man, but I'll see you in San Francisco, I'm sure. Happy

Luca Galante (58:38):
To be back anytime. Thank you, Nicky.

Nicky Pike (58:40):
All right. Thank you for listening to [Dev]olution. If you've got something for us to decode, let me know. You can message me, Nicky Pike, on LinkedIn, or join our Discord community and drop it there. And seriously, don't forget to subscribe. You do not want to miss what's next.