infrastructure at Spotify runs at high speeds. Developers work autonomously, building and deploying services all the time. Backstage is an open source platform built at Spotify that allows developers to build portals for making sense of their infrastructure. Backstage developer portals are powered by a central service catalog with centralized services and streamlined development.
Stefan and Friedrich Weston join the show to explain how Backstage works and their role in developing it. Treasury, if you want to support software engineering daily in a greater capacity, go to softwaredaily.com and become a paid subscriber. You can get all of our episodes without advertisements. Stefan, welcome to the show.
Thank you very much. Nice meeting here. It's nice to have you. So at a large company like a Spotify, there is a problem of service discovery.
And one of the ways that service discovery is solved is through a service catalog. Can you explain what a service catalog is? Yeah, sure. So a service catalog is, at least the definition that we have in Trunguet at Spotify is where you basically keep track of all the different software that is getting developed in your company.
We actually look beyond the service catalog and track all of our software, much libraries, data pipelines, machine learning models, website, mobile features, all of those in a central repository. What we have done on top of that central repository is kind of build what we call a developer portal on top of that consistent data source of our software. And a developer portal is kind of, you can look at it as a single pane of glass, essentially, towards your whole infrastructure and software development platform. And why is a developer portal useful?
So these are a couple of reasons. First of all, we believe in small autonomous teams that can build and own their software end-to-end. And ideally, we want those engineers to be able to, as quickly as possible, build their product end-to-end and spend as little time as possible thinking about the infrastructure and how to do things and how to find information and all those things. So Backstage helps those teams with a standardized way of creating software.
And so Backstage is kind of the starting point for all software creation processes. And the software that you create is also then put into the central repository, which makes it possible for the other teams, like that, you know, or together building a bigger product such as Spotify. Those other teams can find what software has already been built, what APIs are available, what technical documentation there is, etc. So it kind of allows teams to work independently, but still like reuse same tools and same technologies.
Can you give a specific example of how Backstage has been used? Yeah, sure. So I think the best way of kind of explaining the how an engineer uses Backstage as Spotify is whenever you join a new engineer, for example, what we have is something called golden paths. So if you start as a back-end engineer or a data engineer or machine learning engineer, what you do is you go through kind of a tutorial on how to build stuff at Spotify.
So in that tutorial, you kind of go through a number of different steps and most of those steps are increasingly different things you do in Backstage. So as an example, when I start the development process, instead of, you know, going and creating a repository and starting writing code and trying to figure out what tools to use, etc., we have this concept of template, software templates. And those software templates kind of creates a standardized approach to how we build software at Spotify. So rather than trying to figure out what frameworks to use, I go into Backstage and then I select the golden template, as we call it, or like the golden path template.
And after filling in some information, what I get is kind of a hello world application running in production. And everything is set up for me, like the CI, set up automatically, and build started to build automatically. I get documentation, we use a docs-like code approach at Spotify. So you get like default documentation together with your software, you get like, you know, Kubernetes, configuration files, all those things are created for you.
And increasingly the engineer can spend, you know, they can quickly get the standardized approach to building software the Spotify way, if you will. And you know, they can quickly start to just, you know, build the feature or build the, you know, the business logic that they wanted to build, rather than trying to figure out how do I use all these different, you know, infrastructure tools and services that, you know, are growing as we are growing the company. What was your motivation for creating Backstage? So the initial motivation was it actually started as the service catalog.
The Spotify adopted a microservices architecture very early, I would say, it's almost like 10 years ago now. And we also adopted like this model of operation ownership in teams, inside the teams, which is, you know, common devops practices these days. But what we realized then, or what they realized, I was actually not there at the point at that time. But what they realized was that, so you have all these microservices, and they depend on each other, of course, when one service goes down, it has ripple effects across, like the system, right?
Common problem. So the first use case of Backstage was actually a kind of a yellow pages for like a read-only, catalog of all the different services that existed in Spotify, and who owned them. And then on top of that read-only catalog, some clever engineers started to add like integrations with various tools. So you could, for example, click a button to kind of page, you know, page of deuter integrations so that you could wake up the team, that whose service was like, you know, on fire, if they hadn't noticed.
You could find their Slack channels easily, etc, etc. And it's kind of continued to grow from there. And what happened was that it kind of started to grow outside the microservices or the services domain as well. So when we spun up our data infrastructure organization, we started to build out this all this infrastructure for managing data pipelines and, you know, finding datasets and to reuse, etc.
And we kind of used the same principles of extending that common read-only catalog. And sort of when I joined, it was roughly five years, or sorry, four years ago, it had become evident that there was a lot of potential in this system that had kind of accidentally grown into a platform. And at the same time, we had like a lot of proliferation in our tooling that Spotify. So we kind of doubled down and built the Backstage as we rebuilt it from the ground up to kind of be a proper platform, if you will.
And kind of my team was responsible for like, as a central platform owner, we would ensure that it was easy for like other teams inside infrastructure or platform teams that wanted to add to Backstage. So a really important sort of realization that we had when we built that platform was that we wanted not only to create kind of a consistent developer experience for our end users, the engineers that Spotify, but we also focused very much on kind of the contributor experience of Backstage. What I mean by that is that we wanted, you know, the service infrastructure teams to continue building things into Backstage. We wanted the data infrastructure organization to do it.
We wanted the machine learning teams to sort of build their tools so we could get that kind of single pane of glass that I talked about in the beginning. And in order to get there, we focused on making it super simple to build one of these integrations. And we call them a plugin essentially. So you could create a plugin very easily, and you could get that plugin into the central Backstage service very, very easily.
And then kind of after getting approval from the central team, my team then, we kind of made sure that every team that kind of built their plugin could do that independently from us, so that they were kind of set loose on the platform and could build their products on Backstage in a very, very easy way. So you asked about like what use cases, I think now it's even hard to describe all the different use cases. They're now over 140, I think it's 42 different plugins that I've been built by over 60 different teams that's modified. So Backstage is kind of this massive platform that does everything or like it's integrated an integral part of all the different software development processes that we have at Spotify.
So if I'm a service owner or an owner of like five or six services, explain how I'm using Backstage and how I'm integrating it into my project. So first of all, the first thing you see kind of when you're in the backstage is a list of the services that you own. And from there, you can either obviously create new services in a stream line the way, as I said before, but you don't create even though we create a lot of microservices, you don't do that on a daily basis at least. So what the engineer does in Backstage is kind of get an overview of all the different services that they have and sort of the state of them.
So you can, there's a plugin for looking at your CI, recent builds in CI, there's a plugin showing tests and test flakiness for example that you have run. There's a plugin that shows like the cost for example of your services in a service or operator centric view. So you can see not only the total cost of Spotify's cloud spend because that number is not relevant for a single engineer, but then an engineer can see from the lens of their service ownership, they can see, okay, so how much does my stuff cost and are there anomalies for example in that. What we've also found super useful is kind of driving larger upgrades, if you will, or like you know, technical migrations going from technology A to technology B, and we can use Backstage to kind of leverage that surface and put information in front of engineers that, hey, your service is not using the latest technology, click this button to kind of automatically create a full request to move your system over to the next, you know, the preferred approach or just give them the information they need.
So yeah, that's kind of they use Backstage to manage essentially the end to end delivery of their software. That's the switch talk about it. Tell me about the engineering of Backstage. So like, how does it run?
What is the runtime model for it? So first of all, Backstage as a platform is pretty unopinionated. What I mean by that is that what you can build a plugin, what the plugin can be is kind of anything. So essentially a plugin is a piece of JavaScript, almost like a standalone web application that you run in a single, you know, monolithic, single page application.
And those plugins are built with standard UI components that we provide a central team and also like UX guidelines, etc. So a typical engineer, right, the team that builds a plugin, they build a UI front end, a plugin, and then they own the back end part of that plugin themselves pretty much. So for most of the plugins, there is like a microservice that backs that plugin. So in that cost, it costs the insights, the example that I gave, you know, there's a team that owns, you know, the cost insights plugin in Backstage, they operate both, you know, the data pipelines that kind of crunches and summarizes the building information, as well as an API, you know, microservice API that exposes that as an API to their Backstage front end.
So we do, like the single web application is built on React and using material UI and sort of a theme, light theme on top of it. But on the back end side, you know, everyone can kind of bring their own microservice and we don't really have any strong opinions about, you know, those architectures. So say a little bit more about what happens when an instance of Backstage gets spun up. So Backstage, there's actually just in one instance of Backstage.
Then inside that instance, there's multiple sort of plugins or different features spread out. And obviously now, with making Backstage open source, we're, you know, investing quite a lot of time, making sure that other companies can, you know, take and create their version of Backstage. Because kind of the beauty of Backstage is that, you know, every company has different infrastructure tooling and uses a different stack, essentially. Our kind of vision for Backstage open source is that there's a shared like, you know, common foundation, which is the service catalog or the software catalog, these templates and technical documentation.
But on top of that, you should be free to kind of choose and pick and mix from the kind of plugins and integrations that makes sense for you. So let's say that you're, you know, using Jenkins for your builds, there's a plugin that you can use to add to your version of Backstage. And if you're using, you know, Grafana, there's a Grafana plugin, and if you're using roll bar instead of Grafana for monitoring, there's a plugin for that as well. So that's kind of how we envision now other companies using Backstage, not identical as Spotify, but kind of using the same core foundation, but then kind of building their own integrations and quite frankly, kind of hooking up and building also proprietary like private plugins for for the, you know, the internal tooling that they have, because everyone is not using, you know, obviously, like the off the shelf open source, you know, there's a lot of homegrown infrastructure in every company, I'm sure.
So, you know, Backstage allows you to kind of mix open source plugins and open source integrations with your home built, you know, homegrown integrations as well. Go into a little more detail about how a Backstage plugin works. So the first thing you do, if you want to create a Backstage plugin is that you, you know, clone the repo, and then you run a command line, it's a command line interface that basically just like creates a scaffolds a plugin for you. And in that plugin, you kind of add it to the Backstage routing, you know, the global routing, it gives you a dedicated URL on this existing single page web application.
And then it kind of just, you know, gives you a default layout for, this is how we envision, you know, titles and buttons and, you know, grid zone or data should be laid out. But then we kind of leave it up to individual plugin developers, like in their imagination and their use cases to kind of fill in that plugin with information. And our job as kind of the platform providers or owners is to make it as simple as possible to, you know, 14 to own and build that plugin. And we usually joke internally that, like the typical engineer that builds a plugin is like a backend, hardcore, backend engineer from an infrastructure team that doesn't really like writing JavaScript.
So we try to like make it as easy as possible. It's not like a drag and drop easy, but still, there's a lot of like existing UI components that you can kind of pick and mix from. So that you, you don't have to spend a lot of time, like the electric kind of, you know, this build UI or build, you know, JavaScript UI, most of that should be available in the platform. And you should be able to just like hook in your data, essentially, and sort of make those customizations.
And I think we've done a fairly good job. One good example that is that we have something that's modified, which is called Hack Week. So every week, every year we have like a full company, one week where everyone can, you know, hack on whatever they want. And we as the back stage team, we typically, you know, do a little bit like a developer evangelism before and try to like, you know, have introduction sessions to how you build a plugin.
And so far, almost like every year since we have had this platform, you know, there's at least like a handful of new plugins are getting built that week. And I think the cool thing about that is that it's often not just like the platform engineers that builds a plugin. It's actually with the C is, you know, actually our customers, the engineers who are using backstage on a daily basis, you know, they either want to scratch your own itch or they have an idea for a plugin that would make sense for them and their team. And most of the time they can actually, you know, ship a fully working plugin within one week and kind of demonstrate that at the end of the week.
So just for people who might have lost track of what we're talking about, can you describe in more detail how do the services across the Spotify infrastructure or whoever is using backstage, how do they get indexed into backstage so that ownership of these different services is understood? So what we have is a model where essentially every repository or every together with your code that makes up the software that you want to track, you store a small YAML file. And that YAML file is inspired by the Kubernetes custom resource definition, I think it's called basically show it describes like it manifests essentially of like, you know, what is the software, what type is it, is it the website, is it the back-end service, is it a mobile feature, etc. And then it includes information like, you know, descriptions and tags that makes it possible, you know, to browse and search for that and find it across the system.
But I think the most important part of that is that it includes the owner. And we're pretty stringent about like ownership of software that's Spotify. So any one of these components as we call them, which are, you know, a piece of software essentially, needs to be owned by a single team. And a piece of software cannot be put in production unless it's owned by a team.
So that's also kind of how you, so if you want to change the method that about a specific service or even change the owner of a service, what you do is that you open a pull request and you change that manifest file, that YAML file. And at some time backstage goes around and crawls all of those manifest files and index them and puts them in the central service catalog. But the engineers don't go and click buttons in backstage to change metadata. They basically, you know, the sort of truth for what the information is in the catalog is coming from these YAML files that engineers maintain themselves.
And then there's, you know, in backstage the back and system that can scrape and picks up all that information, we also add, you know, a bunch of like runtime information from other subsystems. So kind of injecting additional metadata from various subsystems. One example could be that, you know, we have something called test certification as Spotify, where you're basically, we have like a list of requirements that you want to fulfill to reach a certain level of certification. So if you want to show kind of to the backstage ecosystem that your service is, you're following best practices when it comes to testing and, you know, the way you deploy it is just like we have a background service that kind of checks, you know, goes around and looks at all the services and kind of evaluates them based on these different checks.
And that like that information that we collect sort of on the, you know, deeper along the infrastructure is then injected back into the service catalog. So the UI can be kind of enriched with additional information. So you can get like, you know, engineers and their teams can get like, you know, badges and gamify certain parts like, you know, quality and accessibility, compliance and security and all those other things can be gamified. So again, bad word for it.
But like, you place the visualized sort of, it is the state of your software. There's so much surface area that's covered by backstage. So it's a single pane of glass for all your infrastructure. You've got, you know, metrics and monitoring data, you've got service health, you've got all kinds of dependencies and documentation and stuff in there.
Is there a problem with scope creep and the ability to have all this information be displayed in a meaningful fashion? Yeah, I think that's, you know, we've had to kind of, you know, rethink the layout and circle number of times as, you know, the ecosystem grows or plugins and, you know, consolidating starting plugins that are doing similar things, but in different plugins into, you know, a single plugin and stuff like that. But I think what we've seen is that it's really valuable to kind of make it possible to create or to integrate all of these different, you know, things that engineers needs to know about. You know, they need to care about security, they need to care about compliance, they need to care about costs, they need to care about, you know, test quality and making sure their services is not, you know, their latest deploy is not breaking production and those kind of things.
And what we've really focused on is kind of making all of those different additional things that an engineer needs to care about, part of the developer experience, part of your backstage, you know, views. So, you know, the alternative is that, you know, you have many different islands of infrastructure or islands of tools. And what we found, you know, the bigger problem that we had at Spotify was that, as we built more and more of these tools, you know, as we needed them, it essentially, we started creating more and more of these islands. And therefore, we kind of decided to, it's better to try to, you know, bring all those islands into one, you know, big system.
And then once we have all those things into one big system, we can start to create like consistency between how the tools work and, you know, basically create the map of the tooling ecosystem or, you know, a information architecture that kind of makes sense that is not, you know, spread out and etc. Actually, one of the, one of the biggest blockers that we found when we went around and talked to a lot of engineers at the company was that they're, one of the biggest problems that they had was that they didn't even know where to start looking for information. This was like before backstage. So, you know, different teams put their information in markdown files in their GitHub repositories, some put them in like, you know, Google Docs and some of them in wikis and confluence and etc.
There was like a huge mix, but there was no kind of central information architecture or even a central starting point before backstage. So even though, you know, as when you have, as we do like 140 different plugins and growing, sure, there's like, you have a different kind of problem of like, how do we make sure people find things inside backstage. But that problem, at least what we found is way like smaller than the other problem of having to teach and force your engineers to kind of jump between these different various tools that are like completely on, they're not built together. There's no like a red thread that goes around them.
What are the other difficult engineering problems you've encountered in developing backstage? One of the interesting problems that we had is that as backstage kind of grew and grew, we started to become really like mission critical for Spotify. Obviously, like when when we had like, you know, bigger outages, for example, and actually one time backstage was also, you know, down in a bigger outage that we had, that created like a lot of problems for our engineers because they are used to kind of using backstage as this single pane of glass and this single starting point for both, you know, troubleshooting, you know, failing services, etc. So when they didn't have access to backstage because it was also down, that created like a bigger problem essentially.
So we, at that point, we kind of had backstage running in a single region and we learned a hard way that that's not enough for a company of our size. So we had to kind of re-architect the way we deploy backstage and, you know, we moved it to Kubernetes and made sure that it's running in all the different regions that Spotify uses so that regardless of if, you know, a big part of, you know, the cloud is going down, we can still kind of manage and divert traffic to other more healthy regions, etc. So that was a pretty major effort that we had to do and as part of that process, we kind of reclassified the backstage service as what we call the tier one. The tier one services, other tier one services inside Spotify are the ones where kind of, if this service is down, then music stops.
Like these are kind of the, you know, the hard services that, you know, basically breaks Spotify if they are down and we had to reclassified backstage as one of these tier one services which meant that we, you know, have to be really careful about making sure that we have, you know, great uptime and, you know, additional testing procedures in place to make sure that we don't break production and build scale things. But on top of that, I think the biggest challenge, otherwise, is not, I think, engineering, I think the bigger challenge is more or less like how do you get a company with very many small teams that are autonomous and kind of have an idea of their roadmap to buy into this common shared vision or building everything into one experience and making sure that whatever those teams, these different teams are building plugins, you know, coordinating so that they build experiences that overlap or sorry that kind of, you know, makes sense for the end user. But still maintains the possibility for a single team to kind of own a vertical slice of backstage, if you will, because if they cannot own a vertical slice of backstage and can iterate on that themselves, the risk is that they go outside and kind of build another island of infrastructure and that goes against the whole, you know, strategy on kind of creating one single pane of glass. Tell me more about the templates for services that people can use with backstage.
Sure. So this is a pretty important thing. We talked a lot about like how to balance autonomy and, you know, enable teams to work autonomously. And sometimes you think about autonomy, you think about it in a way that like every engineer should be able to be free to make any choice they want to.
While we kind of allow anything, we try to kind of create standardization at Spotify. And I think this is like sort of a common thread among at least a lot of companies that I've talked to, like since we released Back to Ship and Sources that you want to have autonomous teams making their own decisions, but you also don't want to have anarchy and you also don't want to support like every tool in the book. And you want to try to create some consistency in the way you build software so that ownership of software, you know, it changes hands right all the time. And you don't want it to be like a dreadful experience kind of inheriting a backend service from another team.
So ideally you want to standardize on kind of best practices and the way we do things in our company. And the software templates kind of solves that, or at least a starting point of that problem. So in those templates, the templates are essentially code. And you as a company can decide like, let when we create, let's say microservices or when we create websites, you know, this is the tooling that we use.
And this is how a kind of fresh, newly created software component should look like according to our best practices. So the way we look at it, like we have in the Backseat Open Source project, a couple of like example templates. And those are just examples because every company has their own stack that they're using. Some companies may be building, you know, Spring Boot and Java, microservices, and other using Go and other using a different CI system, etc.
And you know, the Backseat is flexible in that. You can kind of, it allows companies to set up their templates and get out their golden paths as I talked about in the beginning. I think the one of the keys to sort of making this work and making it feel like a striking good balance between standardization and autonomy is that you really want to like invite, you know, the users in to kind of have opinions about those templates. So as I said, they're just code and any engineer is Spotify.
If they strongly disagree with kind of the, you know, the software, you know, framework that we're using or infrastructure that we're using, you know, they can just open a pull request and suggest a change to that template. And if they can argue their case, good enough, and we can agree as a company, we merge that pull request. And then from there on, like everyone uses the updated version of the template. So that's kind of how we introduce standardization without it feeling like you're kind of tying hands behind engineers backs.
And on top of that, we actually also allow like teams to add their own kind of standard templates. They're not going to be like the golden versions. They're not going to be like the, you know, the recommended or fully supported templates that we in kind of the infrastructure provide. But it's fully possible for a team to kind of, if they have a technology that, you know, is not following the conventions or they need to experiment with a new technology or they have a, you know, a different business need for a different, you know, mix of technologies, we don't prevent them from using backstage.
They can actually add their own template there. And we just make sure that to show that this is not like an officially supported thing. So what is backstage itself written? Backstage is written in JavaScript or TypeScript and it uses React and it uses for the UI layer.
It uses very popular and fantastic material UI, open source project. And we kind of add our own, on top of the existing UI components that exist there. We also provide, you know, our own or like, you know, higher level components, if you will, like UX or UI UX patterns. So, you know, a more simplified and standardized table component, graphing components and those kind of things that, you know, most plugins need.
That's on the front-end side. And in the open source, there's the backend is written also in TypeScript and runs on Node. And we, even though, you know, a plugin can kind of use any, any backend they wish to sort of power their plugin, we do provide also like a simple wrapper to, you know, create a simple Node-based backend service. If you just want to have, you know, solve course headers or if you want to just like, you know, store secrets or call out an external API and you don't want to proxy that in the backend.
We do provide a little bit of like a simple layer to create that simplified backend. But typically an engineering team that builds a plugin also brings their own backend, which is where backstage is kind of unopinionated about how you develop that. So if I'm a developer and I've got a new poll request for my service, walk me through how that poll request is going to integrate with backstage. So first of all, you know, all workflows doesn't intersect with backstage.
We like to think about it in like, you know, what are kind of the main interactions or main services that an engineer, you know, should care about. And I first of all is, you know, you have your code editor, obviously, like you should spend, hopefully, the vast majority of your time, like, you know, writing code and debugging code and shipping new features. And then of course, when you're ready to open the poll request, you go to, you know, we use GitHub internally, GitHub Enterprise or GitLab or something similar. But for everything else, you know, you have your code editor, you have your code revision software, GitHub or GitLab, and then the third, that's backstage.
So for everything you need on top of kind of what you don't get from backstage, or sorry, what you don't get from the first two, we want all of that other things to be in backstage. So if I want to, if you want to look at, like, you know, let's say, you're going to net this deployment and how it rolls out into production after you've merged the the poll request, you can do that in backstage. You can even look at like, you know, get a more detailed view on your CI, set up and additional custom things that you're running, you can get that also as part of the backstage. But let's say after you merge your poll request, backstage is there to kind of let you follow your change into production.
I think that's the kind of the best way of describing it. And sometimes for certain workflows, I mean, for a typical microservice or a website, you know, the once you merge your poll request and you, you know, most teams do use custom or continuous delivery, so you can kind of see the code going out into production immediately. But for certain disciplines, like let's say mobile engineering, which is also, you know, representing backstage, the feedback loop for your poll request after merging it is way longer, right? So for example, you merge a poll request, it eventually ends up in, you know, a build that is sent to the app store or to the play store.
And then we have built or our mobile infrastructure team have built backstage plugins that lets you go in and look at your kind of the part of the mobile app that you own that you change that your team is responsible for. And from that lens, kind of look at other things related to that software could be like, how many crashes have we have the features that we own in the mobile client? How many crashes are we responsible for? And you can see those in backstage and similar, you can see performance metrics, you know, for your service, but for your mobile features and whatever flaky tests that you might have introduced, etc.
So it's not almost, it's not always like one continuous flow, you know, going from merging all the way to production, but there's also sometimes like a longer feedback loop for those use cases. What's on the roadmap for backstage in the immediate future? So we launched backstage open source, I think it's about six months ago. Now, and after kind of releasing this, the initial version of backstage was very limited in what it could do.
We had this like brand vision of creating, you know, a single pane of glass for all your infrastructure, but you actually had to build a lot of that yourself because, you know, there wasn't a lot of like open source plug-ins existing from the beginning where actually very few, there wasn't a service catalog, etc. So people were kind of confused with, okay, so I like this vision and I have this problem of, you know, wanting to centralize all my tooling into one place, but this project doesn't really give me that out of the box. And what we heard was that they really wanted primarily kind of this software catalog or the service catalog to be there in place because that's kind of the foundation. So after releasing that, we were extremely happy to see more and more companies adopting backstage and starting to, people started to understand more of like, this is how the products work.
And when they could put that service catalog into production and start to map out their software to it, it was also more obvious like what a plug-in is and how I can contribute like my tool. So we're pretty happy to see kind of now that the starting to become kind of an ecosystem around backstage and the plug-ins are being built. So companies that are using different types, different stacks that we do, that's modified, they are kind of coming up and say, hey, we're using Jenkins, so we built the Jenkins plug-in and then we put it, you know, we contributed back to the project so that everyone that walks up to the project can get that for free now. So we really, like our main focus right now with backstage is kind of to grow that community.
Backstage is kind of like, for backstage to become the product that we wanted to become, we need to be evolving a lot more other companies. We need to, Spotify is obviously going to be front and center and heavily invested in this and continue sort of putting for the foreseeable future the vast majority of the resources to bear. But still, for backstage to succeed, we really want to create like a really vibrant and inclusive community where all the companies like using backstage can feel like they can contribute back to it as well. So on the immediate roadmap, we have things like, you know, API stabilizing the API so that, you know, if you build a plug-in, you don't have to, you know, fear that we're changing the APIs on the hood, then you have to sort of constantly rebuild it on the provides and stability there so that people can feel confident in sort of shipping out and using backstage in production.
We're also working, or actually one of the teams, not my team, but are the teams that are kind of running our Kubernetes deployments and are clusters, they are building a new kind of experience for simplifying and streamlining the way you interact with Kubernetes. I think that's pretty exciting actually because, you know, the promise of Kubernetes is that you as a service owner can get a lot of stuff for free. You just basically, you build your service, you put it into the cluster, and then you walk away and you can sort of trust that Kubernetes does a lot of things for you, like, you know, killing malfunctioning instances and spinning up new capacity as needed, et cetera. But I think actually, like my view at least is that Kubernetes is still very complex for a like non-infrastructure engineer.
So we are trying to build like a plug-in in backstage now that simplifies and takes the perspective of the service owner primarily so that you go to backstage, you have your services, and then you go into the Kubernetes view and you see kind of only the relevant information for your service, not like all the other stuff that is happening in the cluster or even, you know, even knowledge of what a cluster is shouldn't really be there. So that's something I'm pretty excited about, like creating a great developer experience and kind of simplifying ideally a little bit of what it means to be like a user of Kubernetes. So that's under a media roadmap. Fascinating.
Have you seen much uptake from other companies using backstage? Yeah, as I said, we were when we released backstage six months ago, we were really happy to see like on day one people were walking in, you know, opening pull requests and starting to contribute to the project. But and as the as more companies started to adopt backstage and started to put it into production, you know, they realized that if we want backstage to be successful in our company, we need to have a central team that kind of runs it and evangelizes it and helps other platform teams or infrastructure teams to get on board and build those plugins so that they get this single pane of glass. And when those companies are kind of when they made the decision to go with backstage, and there's like at least 20, 20 companies that I know today that have taken that decision and started to create teams to manage by stage.
What we saw was that they also started to make some really significant contributions back to the project. And even though we got a lot of contributions initially, those were typically minor things, you know, fixing UIs and improving the documentation and making it easy to install and stuff like that, all fantastic, you know, things. But what we're seeing now is kind of a shift and our contributions we're getting is like way more mature. And one of the long term kind of hopes we had with releasing backstage into the open was that Spotify would also start to benefit from collaborating with the other companies getting, you know, innovation sort of that we didn't have ourselves.
And I think it's pretty incredible that we've actually already seen that. A very good example is that it was a company who they had one of the major use cases they had for backstage was, you know, central discovery of APIs. So you don't have to know what API you're looking for. You can go to this, you know, explore experience essentially and just find all the APIs that exist inside a company.
And they built like a, you know, added and contributed a fully working, you know, system for that. That scans, you know, standard open API definitions and makes them available. And then other companies started to add on top of that adding like GraphQL support and I think the API support and DRPC API support and stuff like that. So there's now like a fully working feature rich like API explorer in backstage.
And that is not something that we had internally at Spotify. So we're pretty, pretty amazed by how quickly we can also not start leveraging sort of get, get back from the community already. Well, Stefan, that sounds like a great place to close off. Thank you for coming on the show.
It's been a really pleasure talking to you. Now thanks for having me. Keep up the good work. It's a great show.