
Ep. #3, Developer Segments
In this episode, Steve and David dive into listener Matthias LĂźbkenâs topic suggestion of developer segments. David and Steve discuss all the different types of developers that are using dev tools, and the different ways they design tools with these segments in mind.
You can follow the show on twitter @dontmakemecode and email Stephen and David at dmmc@heavybit.com to suggest a topic or guest for the show.
transcript
Steve Boak: You are sort of ensuring your own future by keeping parts of your product open source. It's really hard to defend our choices without talking about it more and knowing why we're making those choices.
David Dollar: It's kind of like a safety blanket for people that are wanting to try it. If we want people to be able to try and experiment with our tools for free, we don't have to run free versions of our software at a loss to be able to do that. We can just give them the code and tell them to go run it wherever they like.
Steve: Hi, I'm Steve.
David: And I'm David. You're listening to Don't Make Me Code, the bi-weekly series where we discuss developer experience and some of the unique challenges we face building developer-facing products.
Steve: Don't Make Me Code is brought to you by Heavybit, a nine-month program for developer-facing startups. For more information, visit heavybit.com.
David: And if you're interested in being a guest on this show, or if you have a specific topic you'd like us to dive into, you can reach us at dmmc at heavybit.com or on Twitter at Don't Make Me Code.
Slicing Up the Developer Market
Steve: This episode is actually inspired by Matthias LĂźbken. He reached out to us on Twitter and suggested that we talk about all the different kinds of developers that are using DevTools and the different ways that we design those tools for them.
So we came up with a whole bunch of different ways of slicing up this market. Developers are not one and the same. And we've got developers in different roles, like front end versus back end, or dev and ops, and even management versus the makers.
And we have different kinds of tools. We have SaaS products and open source products and startup products and enterprise products, and we make totally different considerations for all those different vectors. So we're gonna try to unpack all of those today.
David: Yeah, I mean, I guess we could start with just, why is this even important to think about at all? Why do we need to care what kind of developer is using our product? Like, do we design things differently from them?
Do we price things differently for them? How do we actually think about these developers?
Steve: Yeah, it's funny that in the moment we're not necessarily thinking about all the different slices of developers. We're thinking about our slice. Who are the exact users that we're targeting, and why?
And I think, for both of us, it's just that A, having been around a while, we've seen a few of these different vectors, and B, it's just interesting to talk about all the different things that we've seen in these spaces, and I think talking about it helps us back up our decisions too, that we're both building products for what I would say is a similar market segment, but it's really hard to defend our choices without talking about it more and knowing why we're making those choices. So I think it will be interesting to unpack a lot of this and figure out why we're doing what we do.
Early Adopters and Bigger Customers
At least with us, we're seeing relatively small companies are kind of the early adopters. Are you seeing something similar?
David: Yeah, I mean, so we definitely, we're still pretty early on in building our product, and of course the first people that come to start to use some of these things or sort of your early adopter types, kind of the hacker mindset, generally tend to be from smaller companies or kind of new in their projects, this is sort of a greenfield operation or something. We tend to see people like that more willing to try sort of what you would consider experimental or new technology.
Steve: Yeah, we're certainly seeing a lot of that too. I think a lot of earlier adopters are at smaller companies just because they're the ones that are willing to experiment.
And, for all of us, of course, a big challenge is getting to those bigger customers who have more stable needs and who have more money and who are gonna be long-term customers. And for us that's really been dominant in what we've seen earlier. The people that we approach, the people who like our product the most, tend to be from these small companies who are willing to experiment and who are also on the bleeding edge of technology. But it sounds like you guys at Convox are seeing something a bit different.
David: Yeah, we started off seeing a lot smaller companies, but we've actually now started to see actually some quite larger organizations be interested in our stuff. I actually attribute a lot of that to the open source nature of our core platform. People are a lot more willing to both try it.
They're less worried that we will just vanish and go away. And basically, it's kind of like a safety blanket for people that are wanting to try it.
Steve: That's really interesting, that because your product has an open source component to it, you're seeing big customers approach you as well, because we're just a SaaS product, and so that might be more of a barrier to entry, especially for larger companies.
And that's an interesting gateway. Like with SaaS products, you're targeting a very clear customer set, you're making a lot of assumptions and decisions about who that customer is. But with open source, you've got a product that A, might be more configurable, and B, might serve a much wider audience. And so do you think that that's why you're getting these approaches from larger companies too?
David: I think so. Certainly the ability to customize it to suit your own needs is pretty attractive, especially if you're a larger company and you have some of your own developers or ops people on payroll that can kind of work on this stuff. They like to be able to get their hands into it.
But yeah, I think definitely just, as we started to engage bigger and bigger companies, we get a lot more questions about, like, how long have you been around and how big are you and will you be here next year. And so, being able to give both references from our early customers, but also just, hey, it's open source, you can just keep running it if we were to go away, is really important.
Open Source Versus SaaS
Steve: Yeah, that's interesting too, that there are a few different vectors here of, like, open source versus SaaS that are just funny to talk about, that with open source, I feel like a big part of the way you design the product is around customization. It's going to be serving a wide audience, and so you have to leave that door open for people to tailor it to their needs, and that you're designing it with that in mind, versus a SaaS product, where you're almost doing the opposite. You're making a lot of decisions up front and a lot of assumptions and trying to kind of refine all of the workflows and all of the design aspects of the product around a narrower set of use cases.
David: Yeah, I mean, definitely. And sort of, I mean, that's kind of fundamental to the reason that we actually decided to go both routes to a certain extent, is that the open source is very available, people can use it, they can customize it, and then we've built some sort of opinionated workflows and integrations and things like that as a SaaS on top of that. So we can kind of give both a nice experience for people that want that, or the crazy Swiss Army knife experience for people that want that.
Steve: Yeah, I think it's really funny what you said too about reassuring larger customers that you'll be there, that the open source component of the software lives on when a SaaS can't make that promise, which is a little bit scary to talk about.
Certainly in our space there's this interesting life cycle of companies on both sides, SaaS and open source, where if a SaaS company gets acquired, you'll sometimes see the product just die. The acquiring company might in fact be buying that company to kill the competitor.
David: Yeah. I mean, I guess that actually goes to show it doesn't really matter what size the company backing up the product is, right? Yeah, Facebook and Google kill products all the time.
Steve: Yeah, and for them, like with Parse, they made the acquisition and I guess decided they wanted parts of the product to live on even if it wasn't profitable for them, so they open sourced it.
As a company founder talking about the creation of software that will hopefully live as long a life as possible, I think the open source design aspect is interesting too, because you are sort of ensuring your own future by keeping parts of your product open source, than that no matter what happens to the company and to the software, you've got this piece that can live on, where unfortunately with a lot of SaaS products, your best case scenario might be an acquisition in which your product just gets rolled up into something larger or lost forever.
David: Yeah, it's certainly interesting. The open source angle also gives us, if we want people to be able to try and experiment with our tools for free, we don't have to run free versions of our software at a loss to be able to do that. We can just give them the code and tell them to go run it wherever they like.
Steve: And you let them deploy it internally, and then the expense and the time are on them, and yeah, that's a nice compromise actually. Try it out for free. But if you want a better, more polished experience and you want us to host it, then you pay us some money.
Startups Versus Enterprises
I also think it's really interesting to talk about the different kinds of products we design for small companies and startups versus enterprises. Like, the last company I worked at was in the configuration management space. And so we found a market niche in more middle-tier companies.
And it wasn't on the bleeding edge of technology at all. In fact, we were starting a new company to cater to companies that had been around a while who were new to configuration management, versus what I'm working on now, which is very much on the bleeding edge of technology.
Microservices, AWS architecture and autoscaling. Like, we make all of these assumptions, and because of that, we're very biased towards companies that have these newer stacks and are either newer or have just recently migrated to that stack. And it sounds like you've got a bit of both there as well because of the open source component.
David: Yeah, I'm actually curious, when you say you were dealing with, I guess, older, more mature companies at your last company, do you still find that it's, is it developers coming to you kind of looking for your product, or is it other people inside the company?
Steve: Yeah, that's been an interesting one too, because the last few companies I've worked at have all been monitoring companies, and over these last few years there has been this pretty dramatic shift in roles, where jobs formerly done by full-time operations people are now being done by developers and people with DevOps in their title.
And so things like deploying infrastructure and monitoring, these are being done by devs now, when they were formerly firmly in the realm of operations. Are you seeing similar things at Convox?
David: I mean, definitely. Basically everybody that comes to us right now is a developer, they have an application. They generally have a rough idea of how they want to get it on the internet. We're still seeing a lot of early adopters, Docker enthusiasts and sort of cutting edge tech enthusiasts. And yeah, I mean, they definitely just want to dive right in and kinda crack it open and get working.
Steve: Yeah, and I think it's interesting that you can, like, carbon date a company by the tech stack they're using. They tell you what software they're built on, they tell you how their infrastructure is set up, and you can almost put an age on it. If not on the software itself, maybe on the people at the company, because it speaks very much to the kinds of decisions that are made.
Among startups, technology choices are almost flippant, like they can change monthly, and it's kind of crazy actually. You might be dealing with one JavaScript framework one month and then a different one the next month, and you as a company trying to keep pace are forced to follow these trends like fashion and make sure you're not getting left behind, where it feels like when you're dealing with bigger companies, those choices are more stable.
David: Yeah, I mean, you're exactly right about that. So we try and do a lot of automation around detecting what kind of technology you're using and building things for you automatically. So it's definitely been a treadmill of what JavaScript framework or what Rails 4.1 does this week. I mean, it's just sort of part of trying to make that onboarding experience as nice as possible, but it certainly takes time and effort to keep up with it.
Steve: Yeah, and with bigger companies there are other priorities that you might not even think about for startups, like single sign-on and SAML login, where you might be devoting less time to keeping up with technology trends, but more time to the kinds of customizations that big companies need. Like, we have a shared sign-on login system for every one of the companies, so it makes it easier to onboard new people.
And the dreaded question of when we need to support Windows. Like us, because we're focusing so much on these younger companies who are able to move quickly and make decisions quickly, we have this grassroots onboarding process. You give us a username and password, you give us your Amazon keys, and you're good to go.
We try to onboard you in two minutes, versus a larger deployment of something more sophisticated, you might spend weeks customizing an open source tool to get exactly the right configuration you want and to tailor it to your environment. But once you've got that, it's now an extension of your organization and your team, and you're set for a while.
David: Yeah, I mean, so we definitely tend to have developers be the people that come to us, at first at least, we're trying to experiment the product, see if it's gonna work for them. And we spent a lot of time thinking about how to make sure that, like, everything that they learn through that experimentation process is actually valuable knowledge to actually bring the thing into their company and make it work in production, for real things.
So it's definitely trying to make everything as easy and seamless as possible, but also making sure that we kinda give them little nuggets of knowledge along the way that are gonna help.
Steve: Yeah, that's true. Like we talked about last time, there's this really frustrating part of onboarding users into any DevTools product, which is they might try you out in staging or they might try you out in ways that really aren't production configurations, and you want to make sure you're not wasting their time by having them have to start all over.
Enterprise Sales and Pricing
It's also interesting, even the sales and marketing process, that it's still common practice with enterprise tools to have mystery around your product, to describe in rough terms what it's for, but to have a link to contact sales, and on the one hand it can seem underhanded, but it also seems to have a pretty clear goal in mind, that a big company making a decision like that about what software to use, they may have already made the decision by the time they're visiting you, and so they're just looking for contact information. This is not something I'm an expert in, so I have trouble talking about it.
And I don't know if you've dealt with enterprise software sales or anything like that before, but with the grassroots process it's much more about transparency and automation. Like, get people in, get them to try the product, get them to put in their credit card number. Versus you're dealing with a manager, so get them to a salesperson.
David: I kinda have mixed feelings about that, because, I mean, every time I see one of those buttons on a website it's very frustrating personally. I'm like, I just want to know how much it costs. Like, this is a huge part of my decision making process.
Steve: Yeah, and especially, I wish companies would be clear about who their target customers were. And maybe this is my fault, but we were trying to sign up for this video chat app, BlueJeans, and I couldn't get pricing on their website. And I foolishly thought, okay, I'll enter my email address, I'll have somebody reach out to me. Maybe we'll actually be able to use this.
Well, it turned out their cheapest pricing was something like $500 a month. For a company of six people at that time, that was a non-starter. And I felt like we both wasted our time. The salesperson wasted half an hour talking to me and trying to sell to me, and I wasted half an hour of my time that could have been better spent writing code.
And yeah, it is confusing and frustrating because, clearly I'm not their target customer, but if they just told me that, we could save each other a lot of time.
The thing that's most interesting about enterprise sales, and the fact that a large company might have already made a decision about software before they're even approaching you to discuss terms, that says something about how the company got there, that the inertia that you might have spent years building up to even get this company to know your name.
You get there through the grassroots system. You get developers to love the product. You get them to onboard. And it's only after you've earned it that some dev manager at BigCo will even call you on the phone.
David: Yeah, I mean, definitely. But I feel, having been that developer before, I feel like it's really hard to start to adopt new technology if the pricing is a mystery. So yeah, even before I'm gonna take something to my manager, say in that situation, yeah, gonna wanna ask them or tell them how much it costs.
Steve: Yeah, so this is fun and interesting. So on Twilio's homepage, they actually do a pretty good job of describing the product, of introducing pricing, and of actually giving you access to their tools to start using the product, so that if you're an engineer, you can experiment. But they also have a link on their homepage that literally says "not a developer," question mark. And there's a link to sales.
And so that seems like a really fun, if not tongue-in-cheek, way of saying, like, here's all of our stuff for you, the developer. But if you are a manager, we're just gonna short circuit you right into a salesperson.
David: Yeah, I mean, I actually think that's brilliant. Like you mentioned before, let somebody know exactly who you're targeting with something, a specific message or whatever. If I can come in here and there's a button that I immediately identify with, that's great.
Steve: Yeah, I think the funny thing is, like, the recognition that if you're not a developer, you might actually need to speak with someone to get the information you need, and it's not insulting, it's helpful. They're trying to put a positive spin on it and trying to get everyone what they need.
Front End Versus Back End Tools
We also, as a monitoring company, look at lots of other monitoring tools when we're doing our precedent research and trying to figure out the competition. And we naturally end up looking at front end versus back end tools, and the way that we tailor those tools to those users.
Comparing a front-end tool like Sentry or Skylight, those have a lot of visual polish and they have nice clicky UIs that help you through things visually, versus a backend tool, which might look totally different.
David: Yeah, I mean, I think it's almost hard to even bucket people as to which of those types of things they're gonna prefer. Are they gonna like the clicky UI, or they're gonna like the backend CLI? It's a Vim versus Emacs kind of problem, almost at its core. So it's certainly interesting to think about.
Steve: Yeah, and it's funny that developer experience design a few years ago was synonymous with API design. It was, how are you creating your API endpoints in a way that's friendly and consistent and consumable? And it just assumed, the term developer experience assumed you are typing something into a command line or interacting with an API.
And now, we're both dealing with a space that's developer tools, but definitely not necessarily a command line. And so there's a whole world now of ways that we try to get developers to use our stuff, and how we get them to make our tools part of their daily work life.
But there is still the consideration of who the end user is and what they're looking for, and whether they want a CLI or not is one of those things, and it's a very conscious decision. Like, if you're making a CLI, you need to have a clear idea of who's gonna be using it and why.
Like some of us, myself being a designer, might make the incorrect assumption that people just want a UI, like a nice clean UI is gonna get the job done better every time. But that is absolutely not true. And I think, at least from my experience working with developers, they can get things done really fast with a command line and with the right API documentation.
David: Yes. And not only, like, getting things done fast, but it's also the ability to include, if I ship a CLI, now people can include that in their own scripts and automation and sort of build other things around it.
I basically get a lot of leverage out of my command line by kind of taking all of these repeatable tasks and building other workflows out of them. And so if you have the CLI, you can do that.
If you have a web UI, it's tough to actually, I guess I could technically script a whole bunch of web interactions, but it's a way different experience.
Steve: Yeah, totally. And like, really good documentation with boilerplate code that you can just copy and paste, and making API keys available to people as part of the documentation so that you can make this whole process seamless for people. And yeah, it's not only good design practice for engineers, but a great way of getting people to understand your tools more quickly and get started using them.
David: I mean, there are certainly just certain tasks that lend themselves more to a graphical experience than, yeah, if I want to look at dashboards of my metrics or something, I guess I could technically render that in text at a CLI, but it's gonna be way less useful.
Steve: I'm sitting here looking at the GitHub project page for an ASCII terminal dashboard, and I'm not really sure what to say about it, because I can't tell if this is filling a need for anyone. It doesn't seem like anyone would be searching out for an ASCII dashboard. But for a developer who spends their entire life in Emacs or in front of a bash prompt, like, maybe there's a market for this that I don't really understand.
David: I mean, I guess that could certainly be useful at a high level, but for our dashboards, I love being able to drill in the data, or kind of, sort of the interactivity of the web is a lot more useful to me for that kind of thing.
Steve: If nothing else, it calls attention to the way developers like to play with their tools, and that if you give them a CLI and the right set of APIs to build a dashboard out of raw data, one of the things they might do is build an ASCII terminal inside of Emacs.
Dashboards for Small and Large Companies
And another interesting thing about the way we build UIs, and for me it somehow is through the lens of company size, but the way we present data and summarize data, that at previous companies I've worked at, we've built dashboards, quote unquote. But they serve very different purposes for small companies versus big companies.
That the way you summarize data to a company with 250 employees and a full engineering team, versus a handful of engineers in a room, that you present things to them very differently. Like, for a small company, you might be able to just give them a list of servers in their environment or something and give them a tool, if one of those servers is broken, to restart it or fix it.
But for a big company who might have 200 servers doing that same job, if 10% of them are down, not only might they not care, they might actually have some kind of automation in place to take care of that for them. And so they're gonna be looking at different metrics, like health as a percentage of total something, where I'm not concerned with individual entities, but I'm concerned with trends.
And so that is an interesting thing too. The way we graph things, the way we summarize things, and how we present things, it really depends on the goals of the user we have in mind.
David: So I guess I'm curious, with Opsee, the people that are actually viewing the monitoring or viewing these dashboards, are they mostly developers also, or do you tend to have people sort of in the higher echelons of management that are interested in this?
Steve: In our case, almost everyone we've spoken to has been either a developer on the ground or the manager of a relatively small team who might actually still be writing code themselves. And yeah, so for our purposes, though we do try to wrap things up in summaries, we still try to make it as easy as possible to get to an individual entity that might be causing them problems, like a server or something, and to give them quick access to that.
But yeah, at Convox, it sounds like you've got a bit of both. And I wonder if you've taken some more care about summaries or other things that you would do for larger customers or managers.
David: I mean, that's certainly, I guess, on our roadmap, but right now basically our entire tool is geared straight towards developers and just getting their projects onto the internet, managing them once they're there, monitoring them. We don't really have any sort of the executive summary view yet.
Steve: I think that speaks to the stages that our companies are at too, that we're just both trying to get off the ground right now, and so it's very utilitarian. Like, get the people on the ground what they need to start using the tool. And at least at other companies I've worked at as well, those kinds of executive functions do get built in later, when you start to realize, okay, we have a real product now.
We have a solid base of users, we can start to invest more time and energy in executive functions and the kinds of things that bigger companies will want, because they take time too.
And it's not a deviation from core functionality. It's just that I don't think you can do those things until you figure out if you even have a product to build them on top of.
David: And I think it also starts to happen naturally, you get bigger and bigger customers, and now the people with the purse strings have different needs and different wants, and you're basically trying to make your customer successful, right? So if the person you're trying to make successful now needs the bird's eye view of everything, then you start naturally drifting towards making that kind of stuff.
Steve: Yeah, totally. When you're selling to a dev team and specifically talking to a manager, that manager is probably gonna have their own interests at heart as well. And so you want to be able to give them something where they can find value in the product, and not just their team.
David: Thanks again to Matthias for sending in the question. It was pretty interesting to sit here and kind of unpack some of the different kinds of roles, types of people that use our products.
Steve: That's about all we have time for today. If you're interested in being a guest on the show, or if you have a DX topic you'd like us to dive into, you can reach us at dmmc at heavybit.com or on Twitter at Don't Make Me Code.
David: To learn more about Heavybit, visit heavybit.com. And while you're there, check out the library. It's packed with amazing talks from founders of developer tools companies and other industry leaders.
Subscribe to Heavybit Updates
You donât have to build on your own. We help you stay ahead with the hottest resources, latest product updates, and top job opportunities from the community. Donât miss outâsubscribe now.
Content from the Library
Open Source Ready Ep. #39, Agents Take the Wheel with Zach Smith
On episode 39 of Open Source Ready, Brian Douglas and John McBride speak with Zach Smith, creator of Kplane, about rethinking Kubernetes for an AI-driven future. Zach explains how virtualized control planes could enable isolated cluster experiences at massive scale, while the conversation explores developer experience, AI tooling, and the possibility that future AI agents may each require their own cloud.
The Kubelist Podcast Ep. #53, Render and the New Cloud Stack with Anurag Goel
On episode 53 of The Kubelist Podcast, Marc Campbell and Benjie De Groot sit down with Anurag Goel. Anurag shares his journey from early employee at Stripe to founder and CEO of Render, one of the fastest-growing application platforms in cloud infrastructure. They discuss Kubernetes, platform engineering, bare metal, AI agents, and what the future of application deployment looks like.
The Kubelist Podcast Ep. #49, From Containers to Unikernels with Felipe Huici of Unikraft
On episode 49 of The Kubelist Podcast, Marc Campbell and Benjie De Groot sit down with Felipe Huici to explore how unikernels are reshaping modern cloud infrastructure. They discuss virtualization, containers, and how Unikraft enables millisecond startup times and massive workload density. The conversation dives deep into performance engineering, Kubernetes integration, and the infrastructure challenges emerging in the AI era.

