For those of you who attended the keynotes from NextStep and the OutSystems Developer Conference (OSDC), you'll probably remember our VP of Product, Gonçalo Gaiolas (GG), talking about one particular obsession of his, the one thing that keeps him awake at night and that he wakes up thinking about: developer productivity. (If you didn't get to attend, go watch those sessions now; they're really cool and inspirational, and you'll learn a lot about what makes us tick.)
You see, to be honest, this is not just GG's obsession. Many of us in the company, especially the ones that started out as developers, live and breathe the ethos of the company, the one notion Paulo Rosado, our CEO, started from: that there's a whole lot of technological complexity and waste that is limiting true innovation from companies everywhere.
And, that’s the entire basis of the OutSystems vision: giving everyone the power to innovate through software, and allowing companies to stay ahead of the curve, by abstracting complexity.
This is particularly important, especially as the world and software are becoming more complex. Teams now have to deal with 10x more code and complexity than just 10 years ago, with the potential significant losses in productivity that go along with that.
We want to even that keel, then move beyond that and tilt it to everyone's favor. And all that starts being attainable because we're focusing on our #1 preoccupation at hand: we want to help teams reclaim and accelerate their productivity without having to sacrifice the power of what they get to build.
We want to make developers 100x more productive.
We've always excelled at improving developer productivity and efficiency, keeping the platform evergreen and introducing continuous improvement. And for years now, with this obsession I mentioned and that I share, we've embarked on a massive effort to rethink developer productivity.
When we talk about productivity, we put our money where our mouth is. It's not an obsession if it's not compulsively measured and then backed up through the gathering of feedback to inform the design, development, and evolution of our platform.
Every single decision that is made on our product's features follows a set of general rules, when it comes to the enhancement of developer productivity:
If we can [automate, abstract, accelerate] something, then we will.
Enter the OutSystems Development Productivity Model
How does the whole thing work, to start with?
- We use telemetry and anonymized aggregated product usage data to monitor what activities developers spend their time on. We measure it!
- With that data, we identify the top areas of potential impact to their productivity
- Focused on those top areas, we process user feedback to gain further insights and identify potential inefficiency — this way, we combine quantitative and qualitative data.
- We visualize this data. This becomes a communication tool, common ground and a shared language within the company to make everyone think productivity in a data-driven way.
- We use this visualization and the data in the form of an internal tool for the prioritization and selection of use cases that we believe we can streamline either by:
a) Identifying activities that are wasteful, where developers were effectively wasting their time and either automating or abstracting the complexity of those activities. This is also where AI-assisted development plays a big part for us, as the trusted advisor sitting by the developer’s side and intelligently informing the development process as it flows.
b) Identifying patterns and streamlining activities that are onerous, making them faster, accelerating them for the developer.
This is our operating model and one of the main drivers of our roadmap; it's what enables us to continuously, iteratively monitor and tweak our product towards productivity and fuel the innovation that takes productivity to the next level. This is the process that enables OutSystems users to leapfrog work done with the alternatives: we offer a better, faster way.
This all goes back to our original and previously mentioned ethos, what we call the OutSystems Way of Doing Things. It's pervasive, and at the inception of everything we did in the evolution of our platform throughout the years and up until OutSystems 11. And then, it also helped shape what we’re now calling (codename) OutSystems Developer Cloud (ODC), the latest version of our platform that we just announced.
It's at the origin of the idea Paulo had when he stated that, fundamentally, what he wanted was to make a developer's life better.
It sounds great on paper, right? We assessed our productivity model and discovered that a lot of time is wasted development. So, we did the next OutSystems thing: we killed every bit of waste we could. And then, the model enabled us to identify other areas which could be quickly improved and that had a bigger impact, by just removing their complexity or abstracting them.
Enough talk, let's show what we mean by this, by going through a few examples:
The Road to Zero Training Architecture
As an example, highlighted by Pedro Girão, our Director of Product Management, during his OSDC keynote, 15% of development time is spent on tasks not related to the actual act of development: the 1-click publishes, managing dependencies, opening modules or updating consumers.
Beyond that, delivering complex, scalable, mission-critical use cases requires a well-structured and well-planned architecture that increases the lead time to delivery and requires a highly specialized skill-set.
Industry standards have evolved to highly decoupled microservice architectures that allow independent delivery and scalability but these also introduce additional complexity that makes the development process even more demanding... and slow.
Because of this, we decided to completely abstract and simplify architecture, enabling developers to focus on business value while we manage the architecture complexity for them. Basically, we remove all the wasted development time.
This way, we can ensure deployment and runtime scalability: with each app isolated in its own container and communicating through services. Apps can be independently deployed which ensures continuous agility. A never-slowing, evergreen architecture, if you will.
This new approach is drastically improving developers productivity:
- Minimum overload. With developers only needing to manage dependencies when really required, such as deciding to update the version of a library being used. Therefore, developers won't need to focus on dependencies, for example propagating changes to consumers.
- Safe change. Giving developers the certainty that their changes have a manageable impact, and always providing immediate feedback.
- Minimizing tech debt. Continuously leading developers to keep their applications and libraries fresh, promoting Agile's best practices and avoiding the accumulation of tech debt.
Make no mistake here: we already provide an innovative visual merging tool that makes consolidating changes ever so much easier.
Most of the merges are already done automatically, as we’ve measured that only 15% of merges are visual. What we found out by looking into the Productivity Model is that those manual merges are still taking a big chunk of the time developers spend merging changes: about 73%!
As one of our developers mentioned:
“Automatic merge is awesome and gives us back minutes of productivity! Manual merge is still a pain.”
With our constant obsession about productivity, those manual merges are the next thing to automate. Because of that, we researched and decided to increase the granularity of the merges, to also allow the merging of actions and screens, which eventually led to the reduction of 60% of those time-consuming manual merges.
You publish, and the merges just work!
Unified Developer Experience
We know that the entire development process has evolved immensely, becoming more complex, with a lot of different personas participating in the software development lifecycle.
Today, software development is spread across multiple tools that go from supporting development and configuration of the apps to integration, deployment, monitoring or use cases such as managing your account, training, support, community, and so on.
More tools means more wasted development time and friction as you navigate across these different tools which also require additional context and a steeper learning curve.
So, to remove the inefficiency of a thousand-clicks, we consolidated this whole experience in one single consolidated portal; in what is, essentially, a one-stop-shop for all of those Jobs to be Done — every user journey is integrated and streamlined, just one click away.
Streamlining the Integration with Systems of Record
Today, +80% of new apps require some sort of integration with externally managed data. According to our Productivity Model, when it comes to integrating with centralized Systems of Record (SoR), this typically encompasses on average 40 hours of development for a single developer.
Because of this, to drastically reduce the time it takes, we invested in the creation of supported and out-of-the-box integration with some of the most widely used SoRs, such as Salesforce, SAP, Sharepoint, Microsoft Dataverse or Dynamics or common external databases such as PostgreSQL and MongoDB, just to start with.
Now, instead of those 40 hours of custom development time, integrating with those SoRs can be done in a matter of minutes, if not seconds, so one can quickly start using live external data and dramatically speed up the initial integration setup.
Binary Deployment - Build Once Deploy Anywhere
Finally, we’ve been talking about developer productivity and the truth is that development is no longer solely about writing code. Today, in an agile world that is constantly changing, innovative companies are changing their mindset from project to product. They’re organizing their teams around software products, offering ownership and a track of continuous evolution, instead of having project teams rushing for the next pressing business requirement. This means that developers are now working end-to-end, having to quickly deliver their solutions, getting feedback as early as possible and tweaking their product based on that feedback.
Companies that are Elite performers are able to differentiate in their market delivering unique and custom solutions, deploying multiple times per day (when required, on demand) and taking less than an hour to change their software based on feedback. Netflix, is one of those examples, with the agility to do thousands of deployments per day.
OutSystems wants every organization to innovate and be disruptive in their market with the same agility of the Netflixes of this world, being able to have multiple deployments per day with an extremely fast lead time to change.
As this is such an important part of the development process, we rolled up our sleeves and completely revisited our deployment processes. With a new loosely coupled architecture, and by introducing parallel binary deployments: with code that is compiled once and with only binaries being “transported” from stage to stage along with their respective configurations, we not only managed to drastically reduce deployment time, but also allowed teams to easily deliver independently. Less deployment time and more team autonomy equals more business agility and quicker feedback loops for developers to improve their product.
A big part of our innovation liberation movement starts with enabling developers to be more productive. We wholeheartedly believe that the developer productivity model is great, and we already have a lot of good examples of how we put it to practice to enhance the product.
For this to keep happening, we’ll never stop looking at what our data shows and what our developers tell us. We’ve spotted lots of opportunities to go after already so stay tuned for news, coming soon.
As for myself, I’ll keep waking every day thinking about how we can keep taking developer productivity to the next level.
For us, for developers, and for companies, that is the true, unmistakable meaning of competitive edge.