1. Library
  2. Podcasts
  3. Don't Make Me Code
  4. Ep. #6, How To Train Your Developer
Don't Make Me Code
41 MIN

Ep. #6, How To Train Your Developer

light mode
about the episode

In this episode David and Steve are joined by Gonçalo Borrêga of Outsystems. The group discusses different tips and techniques for training developers in your product, as well as making it easy for your users to show their own value to their superiors.

Visual Modeling at OutSystems
Custom Code and Constraints
A Fast Track to the First App
Champions and Managers
Developers of Every Skill Level
Mobile Apps and the App Store
Keeping Up with Changing Stacks
Developer Feedback and Product Direction

transcript

Steve Boak: You want them to get the reward of having made their first thing as quickly as possible.

Gonçalo Borrêga: If you have an API, you need to have a sandbox immediately right there and see some real results similar to if it was using it in your own work. If they don't realize the value after the first few minutes, it's gonna be very hard to keep them.

We support developers in showing the work to their managers, making them feel successful. It's like a developer learning a new language and trying to push the other guys in the team to come and learn with him because he did this really cool stuff with it. It's the exact same process.

Steve: Hi, I'm Steve.

David Dollar: And I'm David, and 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.

Visual Modeling at OutSystems

Steve: Welcome to Don't Make Me Code. We're calling this episode How to Train Your Developer. And our guest is Gonçalo Borrêga, coming from OutSystems all the way in Portugal.

Gonçalo: Hi guys. Happy to be with you.

Steve: Thanks for chatting with us. We were talking a lot before the recording about your platform and how OutSystems works. And so maybe we can start there. Tell us a bit about what OutSystems does.

Gonçalo: Yeah, so the platform is basically a set of tools completely integrated right from the start that allow you to, instead of starting from scratch and coding your way around to build an app, visually modeling. And you do that for all the layers of the app from UI to the back-end database, the business logic and you can also model it visually, all the business rules, workflows, background jobs, and so on.

So there's a big difference in the way we first approach things, thinking how you can compose and mesh up an app rather than coding it from scratch. So we basically try to put away all that grunt work that you need to do and basically reuse components and reusable pieces to compose that app, and we do that visually.

And on top of that, basically our main goal is really to get apps to production really, really fast and then be able to change them and maintain them with the minimum cost possible.

So we had to think a lot about what's involved when you need to test your application, move it to production, configure it in production, troubleshoot it there, closing the cycle, measuring the performance and so on, getting feedback from your users, and then be able to bring all of that back into the development cycle.

So that you're able to really quickly do those modifications and create the next version to keep updating it in a continuous deployment fashion. So it's basically looking into the entire development lifecycle or the entire delivery lifecycle of an app and basically taking all the bottlenecks out of the way.

David: So that's pretty interesting. The idea of coding visually is kind of fascinating to me. I'm kind of curious, what made you go that route? Does that kind of expand your audience to even slightly less technical people that can now use your product? Or does it just make it easier to work with in general?

Gonçalo: Well, if you think a little bit about even our name, if you think about OutSystems, we started quite a few years ago, even before the cloud term was on, and we had these application service providers that kind of gave you the notion that you could have software outside your systems. That's where the came from. So it was really already kind of this notion of making you a little bit more productive and not having to deal with the underlying stuff.

So we started by having this code generation piece that would allow you to have the minimal set of software in-house while still being able to do all the things that you wanted to do in an application.

So it's not really about reaching the less technical developers or the business developer. It was really about what can we abstract even more to a point that I don't need to build a reusable piece, like in every application I need to have authentication, I need to have authorization, I need to create my database, I need to do all those kinds of things that for eighty percent of the scenarios are mostly the same in every app. So really thinking about how can we abstract that as much as possible.

So without having to write my DDL scripts, without having to write my boilerplate code, kind of having already some scaffolds already done for me, and the right way that we found to do that was really in abstracting those concepts. And by making them visually, we could kind of create these components that you would think about them.

That was even hearing your podcast the other day about even talking to an engine and have it create your application. It was really about this concept of abstracting as much as possible the concepts that you want to have to build this app. So we started designing this DSL, this domain-specific language, really, but we made it visual. That was the only difference.

So it was really about abstraction and productivity for the developer, not really about taking the skill set out initially.

Afterwards that became a really big factor into how we design things and how we design this DSL and the domain of applications that we have, like from web applications to mobile applications. Those are pretty different domains. So the concepts that we have in the visual language need to be very different and evolve towards that as well.

Steve: And you mentioned also that mobile applications are a big part of your product and that I'm sure the visual programming language helps some with consistency and control, right? But in addition to speed, it also helps you get reliable and consistent applications using components.

Gonçalo: Exactly. So if you think about a mobile app and you start seeing common patterns appearing every year, they're different from different type of applications.

The good thing is that the way we design the platform, these components will generate actual code that will run in the back end, in the front end, and so on. And we try to isolate those components so that you can then build on top of each other. Each of these components, and for instance, if you think about frameworks such as React, they're already trying to do this, right?

Getting inside the component all the logic and all the behavior that that component will have, either way some concepts to the developer that will actually use that component. So we put a lot of effort into designing these concepts, into understanding what should go inside each piece of the app that we generate.

For instance, things that we do, since we have this model, we're able to understand the dependencies between the user interface, the business logic and the database. So we're able to kind of package and optimize the queries that will target the database at that specific point because the app is only using one field, so we can generate those queries much better than if you have a developer writing code for a lot of use cases that they have no control over.

Other aspects, for instance, security, or the architecture of the generated app, it's always consistent. So the code that you get is always standardized across the multiple developers in the team. So that's a good benefit that as you start talking to enterprise architects and so on, they also value because they basically end up with, I don't know, dozens of developers modeling applications that end up generating a consistent and standard architecture that they know and that is under control.

Custom Code and Constraints

Steve: You also support these applications when they're in production live, right?

Gonçalo: Right.

Steve: And related to that, so do you allow custom code within the platform as well? And do you then support that when a developer wants to do something that isn't defined as component?

Gonçalo: Yeah, exactly. So that's really the main secret of why our platform is a platform even though it's visual and it's point and click. It's something that developers still, or even very skilled developers, still use because once you start designing a DSL, a visual one, for instance, you target a specific domain.

So you end up designing those concepts around the type of applications and use cases that you know, that you research with your users for the type of applications that they want to build. But we know that we're never gonna be able to cover the full scope of what they want to do. And also a different conversation on that might be related to their creativity and how far they can go with a visual modeling, with a visual design tool.

But to be able to support those applications and the ever-evolving nature of the type of apps that they want to build and the use cases they want to support, we had to design very well in the platform a way for them to bring in their own code.

They will never touch the code that we generate because that's part of the model, that's standard.

But we do allow them to bring in, for instance, their own CSS, their own JavaScript, their own Java or C# for the back end. We do allow them to deploy those components. So for instance, if you want to reuse a library that you already have, if you want to write, I don't know, maybe your own engine to calculate the best pricing for your products and you want to do that by using Java or C, you can do that and you can deploy those assets to the platform.

And from that point on, they are made available in the visual language as if they were any other kind of constructs. So that allows us to kind of never hit the wall when you're modeling because if you want to go a step beyond what we provide, you're able to design your own code, publish it there, and have it managed and monitored and troubleshoot it in the same life cycle.

So that's one of the other aspects of the platform is that I can deploy my own Java library or C# library, I can build a model that uses those components and then have them deployed together to production. So we track the dependencies between that code, we monitor, for instance, when from the visual model your app calls a service that you've written in Java, we know exactly how much time it takes to execute that piece of Java code so that you're very

easily able to find bottlenecks in your code or in the queries that you put in the model. So we make that very visible. So that again, with the goal of reducing the time to change, you're able to find exactly what's wrong with it. And then go back to fixing it or, I don't know, maybe scaling your system if required.

David: So that's pretty interesting. I mean, really thinking about custom code and how somebody can extend your platform. One of the biggest points of value often in these platforms is some of the constraints that they impose on you and sort of the opinions made by the software, and kind of by taking away some of your choices they often make things easier or more consistent, or it just tends to have value in itself.

I'm curious, is there anything that you've any choices like that you've had to make with OutSystems, something that you've explicitly chosen not to allow your users to do, or some sort of customization that they can't do, and basically the reasoning behind that and why you chose to do it?

Gonçalo: Yeah, so those are constant decisions we make every day. So as we talk to developers, as we understand what kind of applications customers want to use, we need to rely on that standard architecture. So one decision that we do make is the architecture of the generated apps.

So there's a set of frameworks that we use and that we generate the apps towards, but that's mostly the only decision that we make. Other decisions around what kind of codes you put into the platform, as long as they run on that framework, and for instance if you think about a standard .NET application that runs on the server, it's the standard stack.

So you basically write pieces of code that will be deployed to IIS as any other app that will be included in the lifecycle of the IIS and ASP.NET execution engine, and that will use a set of low-level APIs that the platform also provides when they need to access components. Like, for instance, if via code you want to access the database, there's an API to do that.

You don't go directly in your connection string and open transactions and so on because we want to make sure that from an architectural point of view you have transaction control from the model down to your code. So there are some restrictions that we put there and we design them very carefully so that applications or code that you make won't put the rest of your application down. So we make those boundaries so that you don't go out of those boundaries.

A Fast Track to the First App

Steve: And so you've made a lot of these decisions up front so that developers can deploy fast and consistent code, and since we're talking about training today, it sounds like you've made many, many of these decisions for developers, and so there's a lot then to teach them when they start using your platform, right? And so what tools do you use to teach a developer that's new to the OutSystems product how to get started?

Gonçalo: So we approach that in two major ways. One way, which is related to training, but it's a little bit different. It's related to how the developers, when they get into our site, they get a first glimpse of what the platform could do for them and help them and so on, is really to kind of show them how we're different and showing that we provide value immediately out of the box. For such a big mind shift, they need to understand that they're going to gain a lot out of it, right?

So I don't want to start testing something if I'm going to spend one hour, two hours, one day, two days on this, and in the end, this is not really going to help me in what I want to do.

So part of the onboarding that we need to cater is around, okay, let me drive him to this kind of fast track process where I don't teach them a lot of these concepts and how we do things. We don't teach them the internals. So it's kind of like this black box that in the first five-15 minutes would allow them to, for instance, create their first mobile app. So it's really guiding them through the process.

We have, for instance, embedded tutorials in the IDE that will tell a developer, okay, click here, use this to create your database table, drag this to the screen and we automatically generate UI for you.

So it's a pretty dumb path, so to say, but it will allow them to realize that, okay, if I really understand this, after fifteen minutes, I can have this simple app that I wanted to build. And that's kind of opening the path to the learning experience which comes a little bit after.

Steve: We've talked a lot about that on the show, about how important it is to get that reward for somebody who's used to making things. You want them to get the reward of having made their first thing as quickly as possible.

Gonçalo: Yeah, that's critical. And without that, I don't think any developer will engage more than one hour with any product.

The product can be excellent, but if they don't realize the value after the first few minutes, it's gonna be very hard to keep them and learn what and how they can do things with your product.

That applies to any kind of developer-based product. Like if you have an API, you need to have a sandbox immediately right there, have the keys available and have them test drive the API and see some real results similar to what you would get if you was using it in their own work. So I think this applies a little bit to everything. So the other aspect is, okay, so it's seen what it can do.

So let's start bringing some of these concepts. And again, we're a very different product, a very different way of doing things from the ones they're used to, not really like a plug-in to their current workflow. So we need to kind of map the concepts that they usually have, so concepts that they have in 3GL languages, with the things that we're doing for him in this visual modeling world.

So as part of those tutorials, so the second one is not as dumb, we already kind of create some challenge for him to kind of feel engaged, explore a little bit on his own. But we bring some of these concepts up and we map them to concepts that he already knows.

Like the simplest example is we have this notion of database entities, which are basically tables in the database. So we start telling him, okay, when you create a table in the IDE, we're going to create this script for you and we're going to run it in the database and we're going to generate this table in the database with this structure. So we can kind of start mapping the concepts that he knows with the high-level modeling concepts that we have in the tool.

For instance, when we generate the constructs in the user interface by dragging and dropping and so on, we tell them, okay, this is the HTML and this is the JavaScript that we're going to generate for you. Can you see there's a mapping here? This is the thing that you won't have to be doing because we're doing it for you.

And at the same time kind of giving them this comfort that, okay, this really looks like something I would be doing.

This is not like this kind of quick and dirty tool that basically runs some obfuscated things in the background. I really understand what they're doing for me and what they're saving me.

Steve: And so you try to be transparent about showing the generated code, that developers, I think, are an audience that really want transparency and they want to know what's coming out the other side of their work, and so do you also then try to show, even if they don't have control over the generated code, you try to show them what's coming out the other side?

Gonçalo: Oh yeah, exactly. And again with two goals. One is for them to learn because they can map those concepts, the other one is for them to feel comfortable, because it's such a big change in the way they do things that they need to trust what we're doing for them. So it's always trying to teach while avoiding some of the resistance that they might have in doing things in a total different way.

Champions and Managers

Steve: You also mentioned that this is a tool that you sell to big enterprises and that you may be selling to CIOs or managers and that developers end up being the end users, but there needs to be something there for managers too. And so do you have tools available in the platform to help managers understand how well it's working for the team?

Gonçalo: Yeah, so part of the success for a manager is really how they can answer the goal that they have from their upper management. And usually this kind of goal is getting this app out there really, really fast, making sure that it's ready to go live, that it's ready to go to production, making sure that the users like it, and so on.

So when we work with these two angles, on trying to work with the managers and the business and so on, while at the same time having our developers enthusiastic and adopting the platform and being productive with the platform to deliver on that app, we need to connect these two pieces.

So we make sure that, for instance, we support developers in showing the work to their managers, kind of making them feel the champions because they were successful.

They built that app really, really fast, and they have the ways and the channels to brag about it to their own managers. So we try to connect, we try to put some tools in the platform, for instance for end users, business users to look into the application that the developer has created for them and right within the app provide feedback to the developer, so things like drawing on the screen on top of the app saying, okay, this is cool, but I would like to have it a little bit more to the right, or maybe reporting defects, and really closing that gap between them.

Steve: You mean redlining, like a manager giving feedback on a product idea.

Gonçalo: Yeah, exactly. And that kind of brings the both guys together with the same goal, which is getting the best app they can out of the way. So it kind of pushes them away from the internals of the platform and into the end goal. So they start collaborating and the outcome is much, much better.

We also need to give them some tools, for instance, when the process is a little bit inverted, so when it's the developer trying to be a little bit more productive and trying to push this new tool, this new way of doing things to the rest of the team. We need to support that guy, that champion really, into first of all, becoming an expert, making sure that our entire community of developers is there to help them with any questions that they have, really making sure that it's successful.

And that he then has the tools to kind of upsell this new way of doing things to their managers or to his teammates and so on. So it's not only about the tool itself, it usually encompasses also, for instance, documentation or material for the developer to show, look, I've been productive and I think you can be too if we use this kind of thing, really helping them sell internally the idea.

It's like a developer learning a new language and trying to push the other guys in the team to come and learn with him because he did this really cool stuff with it. It's the exact same process.

Steve: So is that how you get traction inside an organization, that somebody up high, a CIO, may decide to start using your platform and then the developers have to change the way they work? And so is that a big part of getting a new company on, is getting one champion, one person, to start using it and to show off inside the organization that it works well?

Gonçalo: Yeah, that's usually the process. It's really getting one, two, three guys to understand what the platform can do for them. Usually these guys are already the experts in some of the technologies they have inside. So they can kind of understand how it fits from an architecture point of view, from a technology landscape point of view.

So kind of helping that guy work with some developers that are not as skilled and making them very, very productive. So you end up having this one guy, these two guys that were not the experts up until then, but that from one point to the other they can deliver this app like six times faster than the expert guy that they have internally. And that kind of creates this internal competition between them.

Sometimes it's a struggle and sometimes the guys go against each other, but again, if we think about the end goal of delivering apps faster, people end up at least spending some time to understand the platform, understand the areas where they can still use their entire creativity, still managing to write their own codes and plugging it into the platform, and kind of working in an internal community that helps each other, not only learning but creating new stuff, experimenting new stuff and so on. So it's kind of like this organic try, fail, and succeed process where everybody helps each other.

Developers of Every Skill Level

David: One of the other things we talked about some on the show is that kind of no two developers are the same, right? They can range in experience, they range in, it can sort of be all over the place. So I'm kind of curious. It seems like you might have the same thing where you could have everybody from people that have never even built a mobile app to experts in some sort of existing mobile technology. How do you think about that spectrum of developers and trying to get them onboarded into your product and teach them how to use it?

Gonçalo: So we face multiple levels of skill sets within an organization. So for instance, if you have teams of back-end developers or front-end developers, usually with a lot of expertise in their specific area, then you start having, for instance, guys that come from a Lotus Notes background, Microsoft Access, VB6 and so on. So try to put all of those in the same room and building the same app, and they won't talk very well to each other.

But the key idea here is there's a need for all of them to participate in this app delivery process. So what ends up happening most of the times is that we have, for instance, backend developers creating services in the platform, doing integrations with back-end systems, kind of creating those core APIs for other guys to use and publishing them into the platform, managing that catalog of internal APIs.

And then we have front-end developers mostly focused around using the visual UI modeling capabilities of the platform to mesh up those kind of B2C experiences, those more refined experiences, still working a lot with CSS and JavaScript, but wrapping those components really into reusable blocks that then the other guys, the less skilled ones, can reuse to kind of mesh up those kind of long tail set of apps that are a little bit more tactical, or a little bit less fancy in terms of UI, but they basically reuse the components that these guys built.

So that's kind of a space for everybody, and you end up with having a very solid architecture with very well defined APIs, microservices that feed both these very engaging user interfaces, apps, but also APIs that feed a simple expenses tracking app or travel requests app. So a little bit more departmental applications that are built by these less skilled developers.

And I think the good thing of the platform on this angle is really that it allows you to work at a very high level from these reusable components, but go really, really deep when you want to. So keep using your code, keep using your creativity, keep the control really of what you want to do, but then making that reusable by everybody else in the organization.

Mobile Apps and the App Store

Steve: I'm particularly interested in how that works with mobile apps. And are you using native components across all the different mobile platforms or are you using web components? And how do you manage that for people once they're deployed into the app stores? Because that's like its own set of developer experience, like maintaining something in an app store.

Gonçalo: Yeah. So the applications are hybrid apps, so it's based off web components with JavaScript and so on, and we also package Cordova in the platform and some of the native components are also packageable, so for instance if you want to integrate with beacons or with a geofencing component you basically pick the Cordova plugin, you wrap it into this reusable component that might have a piece of UI to show you a map. It might have a piece of visual logic to, for instance, ask for the current GPS location or get a notification where you enter a geofence. So those are packaged components that you deploy in the platform. And from that point on, everybody can use it in their apps.

So once the applications are ready, you basically click this button that creates the package of the app and basically wraps that into the Cordova shell that has all the native components and the web pieces with a package. And based on that you can deploy it to the App Store, publish it to the Google Android. So you get the final package ready to be deployed. You can deploy it to an MDM solution if you're an enterprise setting.

But basically the process of packaging that, it's an automated one where you could click the, what we call the one-click publish button, big green button that wraps all of those components and gives you the packaged app ready to be deployed.

And also in terms of staging and lifecycle of the app, you have this management console where you have full visibility not only of the front-end apps, but also of the back-end services and APIs. And as you're staging them from dev to QA to production, the platform basically tracks dependencies between your mobile app and the back-end APIs.

And for instance, if you're trying to move a mobile app into production that has a dependency to an API in the back end, and if that API is not compatible with the version that you have in production, the platform will tell you about it. So you're able to kind of manage that integrated lifecycle between the front end and the back end so that when you deploy the app to the App Store, you're sure that the API that you have in production is already a perfect fit, not only to the version that you currently have in the App Store, but also with the new version that you're gonna put out there.

Steve: Oh, that's interesting. I didn't realize who the target customers of OutSystems were, but I mean, I'm guessing this is a very expensive product.

Gonçalo: Well, it depends. If you look into the time it can save you in building these apps, it becomes really not expensive.

And there's a free version that anybody can use. It doesn't have some of the enterprise capabilities. But we basically give you a cloud environment for free, forever. You can deploy apps there. You can experiment with the platform.

We have this, it's like the GitHub for OutSystems, we call it the Forge, where you have tons of open source components, visual components, right, that you can basically install from the IDE. So you can experiment with all of those, you can run them.

We have startups, we have developers that have this side job to help their cousin in setting up a coffee shop, and they build their own apps. They all use the free version.

Steve: Oh wow. Okay. But you also then have the enterprise features to help larger companies work in teams and manage deployment of multiple applications.

Gonçalo: Exactly. And a little bit more flexibility into the deployment plans, like for instance, having it in the cloud, on premises, behind your firewall, having a little bit more control into the underlying infrastructure. So some enterprise or organization-specific capabilities are on this enterprise edition. But the free version basically allows us to build any kind of app. I've built tons of apps in my own personal environment, right?

Keeping Up with Changing Stacks

Steve: Actually I'm interested to hear, now you mentioned things like microservices and cloud versus on-prem, and for a platform like yours one of the things that's been happening over the last few years is this shift to many more companies using cloud hosting and to writing microservices. And so has that changed the way you've architected your platform? Have you had to rebuild the product and components around the changing ways that developers are writing code?

Gonçalo: Yeah, we've been rebuilding it for the past ten years. So if you think about all the underlying stack changes that have been happening, we have a constant evolution on how we generate the underlying app.

The good thing is that when you're modeling, we can basically rethink about the architecture of the underlying app. And from one version to the other, we can generate a totally different architecture while keeping the same functionality up above.

So for instance, you see that with the JEE stacks, they've been evolving a lot. We have new services, we have new queuing services underneath the platform. And as we move from version to version, we evolve the underlying architecture to fit these new paradigms. We're a little bit careful on that.

So if you think about some of the systems that we have running in the platform, we need to not only be on top of the latest trend, but be on top of the latest stable trend.

So we need to make sure that, okay, if I have an application with two million users, if I deploy it from one day to the other and the architecture is different, that application needs to run flawlessly. So even though we upgrade the architecture, we do it a little bit carefully because we need to make sure that that's a stable technology that we have underneath, that it's a good fit to the technology and to the stacks that enterprises already have in there.

But again, if you think about microservices, containers and so on, that's part of the effort that we're doing in isolating, for instance, the way we generate the back-end stack to make use of new ways of containerizing and isolating apps in a cloud environment, not only for our benefit, but also because as you deploy it on premises, customers want to have an easier to manage stack. So we need to rethink the target architecture that they want to deploy it in.

And the same happens for the front end, right? Well, you can think about any kind of JavaScript framework that has been running in the last five years. And you can look into their age and most of them are not more than one or two years old. So we're very careful with that.

We upgrade that stack every year, but we need to make sure that we have this really good strategy to make sure that, for instance, if one of these stacks goes away, we can very rapidly adapt to fit the new better stack so that our customers won't be left with an outdated technology that if they ever leave they won't be able to maintain.

Steve: Yeah. I know that internally when we started using Docker, we were using the stable releases and then we started using the betas because we wanted access to newer features, and then it was at the moment when we decided to start using the nightly builds that we thought, okay, we should probably switch off of this and move to ECS and some managed platform for containers, because it became too risky.

And we actually had a similar issue with React. We started using React.js for the front end when it was still very early in beta, and the code was shifting under our feet. We would write something and then the library would change and we would have to rewrite our component, and that becomes a maintenance burden, and so that's not a good experience either.

Gonçalo: And that's exactly, so think about the visual modeling and the DSL and the code that we generate. That's exactly the issue we wanna solve. We wanna isolate our customers from that shift in the underlying technologies.

So they worry about the functionality of the app and our engineers here worry about all of that, right? Upgrading to the best stack that you have, when there are breaking changes in the frameworks, upgrading those.

We've had customers running one app for the last thirteen years now. They built the app the first day and they've upgraded through multiple versions of the stacks. Up until today, the application is still running, the same app.

Steve: Thirteen years you've been around. Yeah. Wow. That makes me feel better about our application not being as mature as yours. My company's only been around one year, so we have a ways to go.

That's interesting though. Thirteen years. So without specifics, what kind of application have they had running for, you know, over a decade? Or what kind of applications have you seen running for that long?

Gonçalo: Yeah, this one is a telco. It's not an internal app, it's a telco. It's an app that allows third-party organizations to manage their own invoices, their own billing rules and so on. So it's a pretty complex app if you think about it. But the rules have been changing, the way they do business with their customers have been changing a lot also, but the core of the functionality, the core of the relationship with the customers is still there, so they need to keep that app running.

Developer Feedback and Product Direction

Steve: Gonçalo, is there more that you want to talk about?

Gonçalo: Might have something about how we get developer feedback on this type of product and what kind of feedback we have. Some of it is very low level, like please organize the property box by name instead of category.

And the way we make decisions to help those developers in what they need to do sometimes needs to be a little bit decoupled from that and more into the, okay, what's gonna be their challenge in building apps in two years from now?

So is IoT a good thing? Is mobile? For instance, we started building web apps a long time ago. Actually, we started building web technology so you would be able to build these web screens for these small Nokia devices in the beginning of the web.

We moved on to designing SMS flows. We moved on to the web. And a few years ago we moved on to mobile.

So this domain is shifting a lot, and getting feedback from developers, for instance, which is usually very targeted on the challenges or the small difficulties that they face every day as they're using the tool, is very much different from the leapfrog jumps that we need to make from a product standpoint to really be able to cope with this new domain of applications they'll face in two years from now, three years from now.

So that's an interesting product management exercise. It's not really related to developer experience, but the way we manage ideas and feedback from developers that come out of there, it's a struggle to manage.

All of you guys can find me at Twitter at goncaloborrega, so g-o-n-c-a-l-o Borrega. Feel free to jump into the OutSystems community every time. I'm there tracking every conversation and making sure that you guys are productive with it. So we can also talk over there.

David: That's all the time we have for today. We were talking about how to train your developer with Gonçalo, about OutSystems.

Steve: Thanks for listening. 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.