Episode 65
· 41:23
We see there's a real market opportunity to, like, come with a human and developer, like, centered approach that that really builds a product that is much more pleasant and easy to use. And every touch point from using the dashboard to using our CLI to using our APIs, all have sort of that that focus on, like, let's make a great developer experience and great touch point here that we know folks are gonna deeply engage with.
Jack Bridger:Hi, everyone. You're listening to Scaling DevTools. Today, we are joined by not 1, not 2, but 3 guests. So we've got Jonathan, Andrew, and Brad from dev cycle and also tabletics, which we'll get into in a second. But Devcycle is a feature flag management tool, and welcome all 3 of you to the podcast.
Andrew MacLean:Thanks for having us, Jack.
Brad Van Vugt:Thanks, Jack. Yeah.
Jonathan Norris:Glad to be here.
Jack Bridger:So I met Andrew, at a conference. And we were chatting, and I realized that I'd kind of come across, Tabletytics a while back. I think it was, like, I was, like, looking at different mobile dev tools, and, it was interesting about how you could create con like, you could manage a lot of your app in a kind of, like, no code way and do a lot of other stuff as well. And this was the company that I think you were running for, like, 10 years or more. And is that right, Jonathan?
Jonathan Norris:Yeah. Yeah. We've been we've been around for over 10 years now. Like, we, we really came out, I guess, we we did YC. It was part of the the winter 14 batch, and that's actually where I met Brad.
Jonathan Norris:And so, yeah, we've been we've been we've been sort of in business since then and and and growing the business with all the highs and lows that come with being an entrepreneur.
Jack Bridger:Yeah. And so then there's also dev cycle, which I saw that you'd kind of, like you were kind of referencing it on your site, and it seemed like it was kind of this other thing that you're doing. And it sounds like a lot of, it's kind of a pivot and a lot of your attention is on dev cycle, now as well.
Jonathan Norris:Yeah. It's been an interesting story. So the background on Taplytics as you as you kinda described, like, it started off really as a mobile, AB testing, no code visual editing platform for mobile and really grew into, like, a wider marketing automation and dev dev tool, product where we were doing everything from that AB testing to, like, also web no code visual editing and push notifications and audience building and, like, a a a really large suite of of of different, kind of more marketing focused enterprise tools. And, and and really about two and a half years ago, we sort of looked at the the business as a whole, and we're trying to decide of, like, like, how do we how do we accelerate our growth? Like, we're we have all these different products and we we we were feeling sort of stretched thin a little bit across all the different, types of products we were serving.
Jonathan Norris:And so we took a look at, like, the granular detail. We're like, who are the users who are using our product every single day for their workflows? And that was actually engineering teams using our feature flagging tools, which we kinda built as a side project on top of the baby testing tools at Taplytics. They were using it every day to, like, do basically continuous deployment using feature flags. And we're like, hey.
Jonathan Norris:This is like a really passionate group of users using our product, in a way that we didn't really foresee. And and and us internally, actually, we, we had started using feature flags daily ourselves as well. So it really lined up well to, like, our own processes of trying to move faster, trying to get towards continuous deployment, with our product.
Brad Van Vugt:The it's also this was happening, like this was, like, 2017, 2018, like, before feature flags as a service and feature flags as a product was really like an established market
Jonathan Norris:too.
Brad Van Vugt:Right? Like, this is like early, early, early days of this segment.
Jonathan Norris:Yeah. And then and then we sort of took a look at the business and we're like, alright, if we're gonna focus on one thing, we're gonna, like, this is the market we wanna focus on and and dive deep into the developer tool space, building a great experience specifically for for developers. And and that's kinda how how it all started.
Jack Bridger:Yeah. And I actually, that's a kind of interesting point is you said there about, like, if you were going to focus on one thing, and could you talk a bit about, like, the pros and cons of, like, focusing on one thing versus something like tabletics that has such a broad set of features?
Jonathan Norris:Yeah. It's I I think we've we learned some lessons of going broad early. I think I think as an entrepreneur, we learned a lot of those hard lessons of of the context switching. You have you're addressing an issue for 1 customer in one part of your product, then you have to go context switch to another part of your product that that maybe is architected differently. And, and that's really painful and really taxing on on your engineering team.
Jonathan Norris:And so, so that that was a really hard lesson to learn as an engineering manager and as a founder. That focus, especially, especially in the early days, but even even as you're growing, is incredibly important, to to build, build a cohesive product. And, and really what when we made the decision to really focus on dev cycle, we tried to go all in as possible. Like, obviously, we're still supporting those customers and, on Taplytics and and and have people in place to to properly support them. But we wanted to give the teams that were gonna build dev cycle, like, a 100% focus on on that product, and not be distracted by by anything else and have the runway to just go and build, with that that pure focus in mind.
Jack Bridger:Yeah. And what what is, like, the hardest part of of kind of pivoting in in that in that sense?
Jonathan Norris:There's lots of it, but it it the biggest thing is moving our customers, like, moving our customers over and maintaining those relationships. So the nice thing about dev cycle is that we still do the core things that people are using us on Taplytics. Like most of our usage on Taplytics was code based AB testing or feature flagging, and we're able to support that much better with dev cycle. So it's an easy story to go to those existing customers. We've been able to, like, transition a large percentage percentage of them over, because it's a better product, in in dev cycle now.
Jonathan Norris:But some of the use cases, like push notifications is a is an area of our product we we've actively told our customers we're deprecating. And so that that's a harder conversation, but that's where you you work with partners. So, like, we've partnered up with OneSignal, to to help, make that transition of those customers easier over to a platform that's gonna support them long term. And, and so that that was probably the the most and it still is the most delicate balance of of this whole process, but and and making sure that we're we're supporting our existing customers as best we can with. And that's something, I think, we've always prided ourselves on at Tableaux is having really strong customer relations, really great account management, really strong relationships with those customers.
Jonathan Norris:Like, we have customers who've been with us for, like, over 8 years now, which is, like, crazy in in this world of fast moving technology. And those customers are moving with us over to dev cycle because we've invested in those relationships so much.
Jack Bridger:Yeah. That's and it was was like were most of those relationships very much, like, kind of discussions, like Zoom calls, or was it more about, like, setting up, like, early communications over email and, like, updating the docs to say things are deprecated? Or, like, how how did you kind of manage it practically?
Jonathan Norris:Yeah. Practically, it certainly is a lot of Zoom calls these days, but we've I think we've built a lot of those relationships by having people on the ground meeting and meeting with, and making personal connections with with those those customers. And and because Taplytics is, like, really focused on enterprise customers, there's a smaller number of, like, large contracts you need to manage. Where, with dev cycle, we're focusing more on a product led growth strategy and less of an enterprise focus. And so it's it's a bit of a different case for dev cycle.
Jonathan Norris:But with Tabletyx, we we have a really strong sort of account management team and and really as founders, like, not so myself as the CTO, but the other founders, have really focused to make sure we have those founder connections with the executives at our main, our main customers. We have those relationships that we can, we can leverage if if needed to to work through tough contract negotiations and and tough conversations like this. Right? And so, I advise founders to be close with your biggest customers and the executives at your biggest customers, like, never lose that that connection if if you're if you're selling these larger enterprise deals.
Jack Bridger:Yeah. Yeah. That that's a challenging, one. And how how do you think about, like, pricing that you've moved over, like, from, I guess, pricing's hard anyway, but, like, you've already got people kind of anchored to, like, one product that may be, like, completely different. And then you're kind of the same team.
Jack Bridger:Is it was that something that was, like, took a lot of, thinking? Or
Jonathan Norris:Yeah. I think we're frankly still still figuring it out because one of the the core changes going from an enterprise product to a PLG, product is that it's like, the PLG product is comes in at a lower price bracket. Right? We we're trying to be more usage based pricing versus seat based pricing, things like that, which it more aligns our cost to, to customers' actual usage of the product. Right?
Jonathan Norris:There are still, like, enterprise levers that are, like, are common things like permissions and SAML and special connections and things like that, and all the various uptime guarantees and SLAs and things like that, that you can build enterprise contracts around. And so those those transition contracts are still built around the same general enterprise mechanics. But most of our focus of pricing is focused on how do we how do we get those mid market companies that are that are are just gonna sign up for the product and start using it, get them onboarded at a reasonable rate. And maybe Brad can jump in on that.
Brad Van Vugt:Yeah. I I think it's also challenging when you're coming down market from sort of an enterprise focus to kind of like a mid level market. Your your decision maker becomes a lot more technical in most cases. So we're talking to engineering teams. We're talking to engineering directors.
Brad Van Vugt:We're talking to engineering leads, who are making the decision to bring in platforms like ours or even like, you know, in any any platform or any developer facing platform in that sense. And so the conversation around pricing, tends to come up a lot sooner. And also, I don't wanna say there's more sensitivity to it, because that's not necessarily the case, but there certainly is, like, more, awareness to it. Right? Like, I think that if you're a developer, particularly if you're a a developer or technically minded, when you look at pricing, you're you or when you're assessing the tool for the first time, you kind of perform this, like, gut check on pricing.
Brad Van Vugt:Like, who doesn't check a pricing page and sort of their first interaction with a product? And it's not you know, you're not necessarily looking at the mechanics and being like, okay. What exactly is this gonna cost me? You wanna kinda get a sense of, like, is this priced for me or not? Right?
Brad Van Vugt:Like, is this priced for my business and my team for the stage that we're at? What language is being used? What features are being offered? Do things scale on usage? Do things scale on seats?
Brad Van Vugt:Those sorts of questions come to mind. And so the actual dollar amount is is less relevant. We're sort of learning and it's more about, like, how do we position pricing for developers. And I think that's kind of like a unique skill that that we've kind of figured out how to how to do a little bit, and we're still learning a lot.
Jack Bridger:Yeah. That's actually super interesting. It's like the whole, like, transition of suddenly, like, you're speaking to different people, the conversations are going differently, communications different. Is it, like, is it something that's, like, you know, like, old habits die hard? Like, is it, like, if you're kind of, like, a a salesperson that's, like, used to, like, putting relationships with, like, the very, you know, senior senior people and suddenly, like, you're going after a different audience.
Jack Bridger:Is it something that, like, you have to be like, yeah. How how have you thought about that change kind of?
Brad Van Vugt:I I think I think it's interesting, and I'll I'll let Jonathan chime in here as well. But I think the the biggest change that I'm aware of is, you know, when especially when you're selling to more technical teams and and developer developer facing teams, it's really hard to sort of, force timelines. Right? Like, when you're doing, like, sort of traditional enterprise sales, we can do things like, you know, oh, we'll give you a 25% discount if you sign annually. We can, you know, if we can get this deal closed in the next 2 weeks, we can we can do some extra things.
Brad Van Vugt:But when your product is, you know, essentially an an API or an it's infrastructure based, you can't really force timelines on anyone. And that's okay. That that's okay. Right? It's like, what you wanna do is you wanna understand where folks are at in their timeline and where their technical needs are and figure out how we can help.
Brad Van Vugt:And so I think that that's a relatively large shift in sort of the mental sales model that we've I think we've navigated it really well, but we've had to navigate it very, intentionally if if that makes sense. We've had to make our team very aware of, like, okay. We need to work with our customers and their roadmap and their technical priorities and make sure that we're fitting into what they're doing rather than trying to trying to drive just sales for the sake of sales. Yeah.
Andrew MacLean:I feel like that's why, like, in such a big way, Devcycle has really doubled down on, like, we believe in developer relations and, like, that relations part being the thing, like, relationships. Jonathan was talking about it earlier. Right? Building those relationships with enterprise customers is, like, one of these ways that we've been able to sort of transition folks over to the dev cycle platform. And I think as as a company internally and externally, like, as part of this transition, so much of that conversation has been, like, let's focus on relationships.
Andrew MacLean:And, like, through that, all of these other great things are gonna come, and we're gonna really take the time to to invest in the folks that are coming over to not only use our platform, but to just engage with us, to really sort of move the needle in in a in a different direction than than it might go if we were, say, just really trying to sell sell sell to developers. And I think that's why DevRel exists. Right? Like, this industry did not exist for, like, 10 years ago because dev tools were just not in the place that they were. And now you've got a whole group of people whose entire job it is is just to, like, build relationships with the developers.
Andrew MacLean:And that's such a unique piece, I think, of what we've kind of done as part of this transition is really sort of go all in on relationship building with people.
Jonathan Norris:Yeah. For for our sales team, it's been a big shift because they now have to think about sort of enterprise sales. Like, yes, we still have inbound enterprise interests that will go through that standard enterprise sales process. But the majority of their time is focusing on on what's called product led sales, where they're they're looking at how people are using the product and reaching out to them at the times where we can see that, okay, like, they've deployed this to to to production. They're they're getting value out of the product.
Jonathan Norris:Like, now is the time to to have the conversation with with them, figure out who's the right person to have the conversation with about what what a contract looks like. Right? It's not about, like, everyone who signs up for the product gets, like, blasted with emails and phone calls right away. It's like you need you need to have your product lead and create that hook of of interest in in in usage of the product, and then you can engage in in that conversation about, like, alright. Here's what a, like, a discounted contract might look like or something.
Jonathan Norris:Here's what the enterprise features are might look like if you're interested in in them. And, and that I think has been a a big big shift that we're we're obviously still working through.
Jack Bridger:Yeah. And, could you talk a bit about, like, how you like, the kind of, like, practical things you're doing to kind of build these relationships and and this kind of, like, product led growth?
Brad Van Vugt:Yeah. I I think I think that's tricky and you gotta be really careful and intentional about it. You know, one of the things that we do is we try to be very open and public and readily available to our to our community and to our customers. And so, you know, things like a a a discord that anyone can drop in and and talk to talk to Andrew or even talk to John you know, talk to a c level, talk to a founder, most times of the day. And that helps, you know, for some people, that's really great.
Brad Van Vugt:We also do a lot of things. We do a lot of engagement on Twitch. We do a lot of engagement on on on YouTube and try to be as as live and as accessible and as human on the other side of the platform as as we possibly can. And I think if we do that correctly, we do that, honestly, and we just try to be helpful, then then then we'll get where we need to be on on that front.
Andrew MacLean:Yeah. I feel like that that piece about authenticity. I'm trying to think of the word. It's but and and it can't it's not popping into my head right now. But there's this concept that every single person that is part of the dev cycle team for every customer who's coming in, all of this is a personal relationship.
Andrew MacLean:So, like, having these conversations, our entire team is available on pretty much any channel that you wanna go on to Everybody on our team from marketing to sales to account management comes on, comes on any of the the the media that we do. I mean, the fact that there's 3 of us here on this podcast is kind of the way that we run things. Like, the more of us that can get out there, like, we don't want this to be the Jonathan show or the Brad show or the Andrew show. We want this to be, like, the dev cycle developer show and, like, really make this about that experience of of seeing all the faces behind this technology. Because we all know, like, when when things go down at the end of the day, you're gonna wanna engage with a person, and and you're gonna wanna do that in whatever way feels most comfortable to you.
Andrew MacLean:And so we've been really spending, I think, the last, especially since we came on board the dev cycle team, like, the past year has really been dedicated to trying a lot of these different spaces and seeing what works best. I mean, we were in London, England with 2 of us that were there doing 2 conferences on totally different topics Because it's the thing we wanna see, like, where are where is the audience? Where are people? What can what value can we provide to the world outside of just, dev cycle and feature flags? And it's also because even at both those conferences, at neither of those conferences did either of us talk about feature flags.
Andrew MacLean:We were talking about, like, here's our expertise that we have in this area that we wanna share with the world. And by the way, we also work for this awesome company. He does this really cool thing. And so if you wanna come over here and see what we do, like, we wanna give you this, to to kind of allow you to to get some insight into what we really wanna provide out into the world. So put out good things, and and good things will come to you.
Jonathan Norris:And I would say it also all wraps back to, like, our our focus for dev cycle, which is, like, it's actually focusing on the developer experience. Like, we know feature flagging is not a new space. There's a large sort of incumbent provider, and there's, like, a multitude of open source tooling and, internal tools that that team's built, across 100 or maybe thousands of companies out there, likely tens of 1,000. But we we see there's a real market opportunity to, like, come with a human, and developer, like, experience centered centered approach that that really builds a product that is much more pleasant and easy to use. And the reality for teams that are using feature flags, like, it's a tool that you're potentially using many times per day in your workflows.
Jonathan Norris:And, if any any frustrations or or or things that get in your way in that workflow can really quickly cause you to lose trust. And so that's why, like, our focus for dev cycle is really focusing on that developer experience and every touch point from using the dashboard to using our CLI to using our APIs to our ID integrations are all have sort of that that focus on, like, let's make a great developer experience and a great touch point here, that that that that we know folks are gonna deeply engage with once once they start using our products. So, it all kind of ties together and, creating a great experience for our customers. And, that's how we believe that we can be successful in this, like, kind of existing market that that we know. There there are large large players and large internal tools that we're competing against.
Jack Bridger:Yeah. That's so so developer experience is kind of the way that you're, seeing can kind of take you to that that, you know, to wherever, I guess, becoming the new incumbent.
Brad Van Vugt:It's certainly been successful so far. Right? It's kind of been the core the core piece of the puzzle that's really working for us. And so we're really looking to double down on it in a in a in a genuine in a genuine and helpful way.
Jack Bridger:Yeah. That's, one of the questions that I've asked, like, a 1000000 times on this podcast is, like, whenever anyone mentions developer experience, it's like, if if I speak to every dev tool, they'll all mention developer experience, and I'm sure, like, the incumbents mention it. And I'd be surprised if they didn't anyway. And, what what is actually the difference between, like, saying developer experience is important and it, like, actually really reaching the user and being significantly better than experience than other tools?
Andrew MacLean:That's the $10,000,000 question. You just asked it. Brad Brad, this is all you.
Brad Van Vugt:So, I mean, we we have pretty strong feelings here, and I think I think it's important to have conviction when we say things like developer experience. I know, internally, we don't really talk about developer experience. It's kind of more of an external industry term. But what we talk about more than anything is the quality of our product offering. So when we think about developer experience, we think about the quality of our SDKs, the quality of our API.
Brad Van Vugt:We wanna make sure, like, we when you're building and and and selling to developers, there's if you do things well, there's an incredible amount of loyalty. And and that's wonderful if you can if you can get there. There's also, like, there's a 1,000,001 ways to lose trust very quickly. And so when we're talking about developer experience, what we're talking about is ways to make sure and go, like, not just above and beyond, but above and beyond times 3 to make sure that we are not losing that trust, especially early on in the relationship, and then making sure that we are maintaining it. And so the way that we go about that is not like, it's not enough to say, you know, using our CLI is a delightful experience.
Brad Van Vugt:That's that's not a thing. Obviously, the industry likes to say that sort of thing. But what we wanna make sure is, like, you know, that it it works as it's expected. It works the first time. It works wherever you are working, and it and it works bug free.
Brad Van Vugt:And those are sort of the some of the core principles that we operate, and and we sort of sum that up to this idea of, like, what is the quality of our developer experience and what is the quality of our developer experience compared to the rest of the market? And a core a core principle that we operate on is like, okay, let's make sure that we're delivering a developer experience of a high enough quality, that we stand out that we stand out in in in the broader segment.
Jonathan Norris:And I think the biggest change as, like, myself as a CTO, is that it's not about, like, building, like, the flashiest, most marketable features. And I think getting that out of my brain was, like, one of the biggest changes that, like, it's you're not focused on, like, flashiness and and capturing attention. You you're focused on, like, building a great core product that delights more than it frustrates, right, and and builds developer trust over time, and and and really removes those frustrations and pain points and and and hiccups that every product has, even ours, and and and really iterating on on those, like, those core things that you do and continually iterating on them and making them better over time and and and doing that more than than sort of working on the next flashy feature that you think will, like, get you all the attention in the world, once you build it because that's not not not true most of the time.
Jack Bridger:Yeah. That's that's actually, I think, is a really good point. I feel like a lot of it it's like especially, I find if you're like it it can be really hard to, like, not create a feature and, you know, publish. Like, here's what we did, like, this week. Sometime, you know, these change logs that don't you know, you want to put out this massive feature that so that everyone's talking about you on Twitter.
Jack Bridger:Like, oh, these guys ship. Like, oh my.
Brad Van Vugt:I feel it feels like it feels like success. Right? It feels like progress, but it's it's really it's really not that.
Jonathan Norris:We spent months on, like, a custom, like, test testing system to ensure the consistency and quality of our server side SDKs across all of our platform is consistent. And, like, that's not sexy at all. But it, like, it ensures that when we're making changes to those SDKs going forward, like, it's consistent across all of the SDKs, and and we can we can ensure some level of quality there. And, like, it's those types of things that over time will pay off, but, like, definitely is not something we're gonna market, on our on our public marketing page
Jack Bridger:right away. Yeah. And I guess, like, the whole, I mean, in a way, like, the whole move from tabletics to dev cycle seems like a kind of, like, microcosm of this idea that you're just, like, focusing on making, like, fewer things really good. Is that is that kind of like the
Jonathan Norris:Yeah. Yeah. We we we definitely learned a lot of lessons with with Taplytics. And, like, to be frank, like, Taplytics was a pretty successful startup in in the grand scheme of things. But, we got to a point where, we I think we had built too many features for the side of size of our team, and and trying to support all those features just became a burden where it was really impacting our growth.
Jonathan Norris:And and and and that was a hard lesson to learn and and really, helped, yeah, solidify our our convictions around creating a more focused product with dev cycle that that that more solely focused on on individual developer experience of this this more narrow but much deeper product, than than Tableau X was.
Brad Van Vugt:I, I know you're joking earlier, Jonathan, about, like, you know, you don't really wanna talk about all the testing we've done. But now I can't stop thinking about, like, a landing page. It's just like dev cycle well tested. Like, maybe that's interesting though. Right?
Brad Van Vugt:Like, that would that would stand out. Yeah.
Jonathan Norris:Yeah. All that stuff is open source. We could we can point to it. But yeah.
Jack Bridger:Yeah. That's I mean, I guess, with with evidence is, like, people love it. Right? If you could just show, like, here's what we did. Yeah.
Brad Van Vugt:I mean, this is this is this is the effort. This is how we think about building products and how we think about building things for for other developers. And it it really I don't know. Maybe maybe there's something interesting there. But I, I, I like the idea of maybe there is a way to talk about that publicly.
Brad Van Vugt:That's, that actually is interesting.
Jonathan Norris:I think it relates to how we're sort of approaching open source with dev cycle and how that also is very different than tabletics. So with Taplytics, we had, like, we had patentable things in our SDKs, that, that we had built very early on. And and it meant that we we could never really fully open source a lot of the the SDKs and software that folks were installing into their, into their applications. And with dev cycle, we wanted to revert that totally. We wanted to make every piece of software that folks are installing in in their applications or their servers or or or their integrations to, to things like GitHub and things like that.
Jonathan Norris:We want all that to be open source, and and and that's really kind of been a core focus of us of ours and has allowed us to be open with how our SDKs are built, how they're tested, what's our process behind all of that, and, and really led us to supporting this new initiative called Open Feature, which is a CNCF sandbox project, Cloud Native Foundation, the foundation behind Kubernetes and and lots of other pro projects like, OpenTelemetry and Argo CD and and and whole suite of amazing open source projects. And and open feature is kind of a new, a new project that that is coming up in the mold of open telemetry where it's a vendor agnostic interface to using feature flags in your code. So instead of using dev cycles SDKs directly, you use open features SDKs that have a kind of a agnostic interface to getting feature flag values, and then you sort of plug dev cycle or really any other provider into that interface. And, that's a, Yeah. That's that's an open source project that that we're very excited to to support, over over the long term here.
Jonathan Norris:Yeah.
Jack Bridger:And I mean, like, Andrew, I guess, like, on the ground, like, speaking to so many developers, I'm sure that makes, like, a big, have you noticed, like, a like, the the conversation is kind of easier when you've got so much of, like, an open source kind of angle?
Andrew MacLean:Yeah. I think it was so interesting. So we spent last week in Chicago at, at KubeCon, which was kind of like our our our, like, sweet 16. It was like our coming up party in this in this this world of, of cloud native. And it was so interesting having these conversations because folks were like, so how do you feel about open source and, like, what?
Andrew MacLean:Why do you do the open source things you do? And we said, it this is it. It's the community. It's this. Why this is here.
Andrew MacLean:We wanna support this. And it just made those conversations about, okay. Now tell me about your SaaS platform that I'm gonna have to pay for eventually. It was so much of an easier segue that was in there. And then when we focused on things like, yeah, but we have, like, this usage based pricing and all of these things that, okay, I can use this now as a developer and make it so easy for you.
Andrew MacLean:Yeah. The it it it's such a it's such a door opener in this world if you're especially if you're a SaaS platform here because there are a number of really, really, really good open sort fully open source self hosted, feature flag providers that are doing really cool things. And so the question often comes, like, why why do you why why are you not fully open source, or or or why why the the SaaS model? And, and I think sort of saying, like, you know what? We do this because we think that with this model, we can offer you the best possible developer experience.
Andrew MacLean:We have the resources in the team to be able to do that, but, also, we really wanna support you in being able to do that in the way that you want to through open source. Yeah. It's been such a, a huge, door opener for these conversations with developers to have them believe that we are truly a developer focused company.
Jonathan Norris:I think it helps most too with the migration discussions. Right? Because you can imagine a large code base that's been using feature flags for a while might have 100 or thousands of flags throughout their code base. Right? And if they're going to migrate to from an internal tool or a different provider, they're never gonna wanna do that ever.
Jonathan Norris:Like like, it's such a large pain to overcome in that migration process that they only ever wanna do that once. Right? And that's where we can we can point to open feature to say, hey, you only need to migrate to using open features interface once. And then in the future, if you wanna change providers or build an internal tool or something like that, you can do that with Open Feature by plugging in kind of a different provider. And so it's really helped with those conversations and getting those those conversations going.
Jonathan Norris:There's still, obviously, a lot of work. Like, we've we've built, tools to help our customers convert from from one platform and our internal platforms to another and having open APIs and and schemas and things like that, help enable that process. But, but that's kind of one of the biggest hurdles for us. Like, we know for us, like, the biggest hurdle is actually, like, folks who are using other kind of internal tools or very simple feature flagging things, like using environment variables to start or using, like, a a simple file that's served by a CDN or by a database or a Redis or something like that. Like, that's where people start, and we know that.
Jonathan Norris:And if you start by hooking that up to, like, open feature, it would make the conversion to a provider like ourselves much easier in the future and and reduce that that overhead. And and so that's that's the big motivation behind why we wanna support it.
Jack Bridger:Yeah. Yeah. This is funny how it's, like, I often come on the show and it's, like, you think that, like, for instance, with authentication that the biggest competitor is gonna be, like, off 0, but it's actually just, like, people doing it themselves. And yeah.
Brad Van Vugt:Yeah. It's always it's always just folks' own database. Yep. That's exactly it.
Jack Bridger:Yeah. That's that's really interesting. I think we're coming to the end of the time. One, before we do kind of a roundup, on dev cycle takeaways, I wanted to do, like, a mini interview within an interview, and we'll keep it to, like, a minute or so. But I know Brad and Andrew, were both, working on Battlesnake, which, I, came across a while back, which was like, you you it's like, a place where senior engineers can learn by building difficult things in new languages.
Jack Bridger:And I just wondered if you had any kind of, like, takeaways of that experience, that you've kind of brought with you to dev cycle.
Brad Van Vugt:Yeah. I mean, Andrew Andrew can talk about this a lot too. But I think that, Andrew and I spent a lot of time working on and and building Battlesnake and finding ways to build developer community, build trust within developer communities, and also build, what we think of as like safe spaces for senior developers. I think it's hard to be a senior developer in the wild. It's hard to be a senior developer on LinkedIn, for example.
Brad Van Vugt:The the it's a very busy and noisy space to be in just always. And so, we've learned a lot about what it means to build an, you know, an honest, and open and authentic developer facing brand. And we've we've you know, a a lot of the reason why we joined the dev cycle team was because we wanted to bring that experience to to dev cycle specifically. And so there's there's, you know, an endless amount of things that we learned, building building Battlesnake, and I think that all of it sort of applies as as we go forward. I don't know, Andrew, if you wanted to add anything else to that.
Andrew MacLean:All I was gonna say is I think there's, there's something that, you don't necessarily think of, when you think about building a developer brand. And it's that, like, developers are, like, people first, developers second. And so creating experiences that they can share their love of what they do with other people, is so huge. Like, I think one of the things that we, brought from Battlesnake was, like, people loved going and watching these tournaments with their families. They would they would have watch parties, at these events.
Andrew MacLean:And that that carried over to KubeCon last week when we had baby onesies, that have, like, future engineer on them, and they had our little toggle bot logo on them from dev cycle. And they were, like, the hottest item there because, like, this is the thing. Right? It's like especially when you look at senior engineers, professional engineers, they have families. They want they they're thinking about things outside of just, like, sitting in a computer all the time, and and they wanna have this experience.
Andrew MacLean:And so so much of that making your life as a developer something that's, like, of interest or exciting to those around you, I think, is such an important thing. And even with a platform that only focuses on putting conditional statements in your code to control whether or not you could see a feature, like, there's ways to make that a thing that everybody can can experience. And and and I think that's that's a big piece of of not just making, a developer brand fun for the developer and engaging and meaningful and powerful and and really well constructed, but also making it something that's accessible to everybody around them as well.
Jack Bridger:Yeah. That's pretty good. So developers are people. That's
Brad Van Vugt:a really good help. I know. Yeah. Developers are people. They they have families.
Brad Van Vugt:They have interests. They have hobbies outside of coding. You know? And not every developer is just learning to code all the time and sitting in a dark room in their basement at 2 AM writing writing, writing code. The, you know, they're they're just at the at the end of the day, they're just people.
Brad Van Vugt:And so finding creative ways to treat them like people, and and treat them like a diverse set of people, go goes a long way in help building brand and just helping build trust and loyalty.
Andrew MacLean:And that's it. If you are sitting in your basement just learning how to and just coding all the time, we are here for you. We see you. Nice. You are our people too.
Andrew MacLean:We don't want you to feel left out. We have things. There's things for you too, and we're we're here for you as well.
Jack Bridger:Yeah. I'm not in a basement, but I don't have any windows in my office. So I felt basically kindred with them as well. Jonathan, do you wanna round us out with, anything that you, would advise to a a dev tool or, like, think biggest things you've learned along the way?
Jonathan Norris:Yeah. I I think that's that's a good question. I think, I think Brad really summed it up well earlier that creating a dev tool and focusing on the developer experience is is really focusing on that core product and building that relationship with your customers through the the the quality and the experience of of of the product that that you're you're providing to them and and focusing on the details and focusing on those those little frustrations and and focusing on your documentation and and and how those those interfaces are far more important than creating, like, the flashiest UI or or or or anything like of that sort that those day to day experiences of using your product need to be continually iterated on, and and refined to to create an actually great developer tool and and developer experience. And I think that's been our biggest learning so far and and one more we're continually working on. And, like, we we certainly aren't I don't think we'll ever be finished, but, that's why we're gonna continue to iterate on and and improve and and listen to our customers of of how we can make the best sort of experience for them of how to use feature flags every day.
Jonathan Norris:Like, we want people using our tools and relying on our tools every day in their workflows and and that's that's what we're laser focused on.
Jack Bridger:That's really good. So we've got 2 great insights there. Focus on the parts of the product, the product that really matter and make them really good. And remember that developers are human and have lives as well. Thank you, Jonathan, Brad, and Andrew for joining.
Jack Bridger:If anyone's interested in checking out dev cycle, devcycle.com. Go check it out. And, yeah, thanks everyone for joining.
Andrew MacLean:Thank you, Jack.
Brad Van Vugt:Thanks, Jack.
Jonathan Norris:Thanks for having us.
Listen to Scaling DevTools using one of many popular podcasting apps or directories.
