In collaboration with:
As a pre-sales consultant at Atos, I spent most of my days looking for the best technology solutions to support our customers' digital initiatives more efficiently. Although Atos adopted an agile and a DevOps way of working a long time ago, we knew there was still something crippling our speed of delivery. Something that in a competitive environment like the consulting industry, we couldn’t afford.
The thing was, even with an Agile methodology and mindset, it took our teams a long time to develop with traditional tools. More than our customers expected. And that wasn’t all. Every time we had a new project, we needed to assemble a new team from scratch with different roles and different technical skills, depending on the technology used. And believe it or not, a lot of communication and effort is spent on building a team.
So, we started developing a vision for a new way of working that would help us take a step further to improve our productivity and the value we deliver to our customers.
Making the Leap
For a long time, we’d been saying that we needed technology that would support our agile mindset by increasing our speed of delivery without compromising the quality of the end products. In other words, we needed a solution that would allow:
- What we call “all-hands” software engineers. That is, we would no longer separate our engineers by a function like a tester, a developer, and a product owner, but have all-hands software engineers who are productive throughout the software life cycle.
- Fixed teams. In product organizations, especially when you have mixed service models, it’s normal for each team member to move to different assignments once they complete a project. And when the new project starts, you have the whole process of getting acquainted with each other and discussing the preferred way of working. With fixed teams, when one team delivers a project successfully, we keep the team together for the next assignment.
The degree of automation provided and the repositories of reusable, open code modules, connectors, and UI like the Forge, are what made OutSystems the perfect low-code development platform to enable our goals—and more.
Changing With Low-Code
We had used component-based development and service-based architecture before, but it wasn’t really implemented in the organization because it took too long. Architects would study a service-oriented architecture for years, and when they started the project, something else always came up.
With the OutSystems low-code platform, we can implement the architecture at once. We’re able to create a more transparent architecture, which, combined with the speed of development, allows us to reduce significantly the complexity of current application landscapes.
By choosing OutSystems, we were also able to give developers who specialize in older and outdated technology (like 4GL languages) a “second career.” Java architects were more resistant because they don’t perceive the power of a low-code platform immediately and don’t believe it’s capable of developing complex applications. Fortunately, we have great use cases that showed them otherwise. Atos Australia, for example, built the asset management system for the Royal Navy of Australia, New Zealand, Malaysia, and Oman in 18 months using OutSystems, when in Java it would have taken them years.
In fact, rebuilding legacy applications is always a good low-code story. Technologies that were popular years ago, like COBOL, C, C++, Visual Basic or Oracle, for example, today weaken IT’s capacity to innovate and collaborate, increasing legacy gridlock and technical debt. Plus, maintaining an aging system usually comes with high costs associated with the contracts with the vendor and keeping scarce resources and skills. That’s where OutSystems can help.
What’s usually an eye opener for our customers is that they don’t have to get rid of legacy systems; they can simply and quickly rebuild them using low-code. And, it goes along with a positive business case. We had some business and mission-critical systems built in just 14-18 months. And by capturing the legacy DNA combined with a model-to-model transformation, we can preserve the application knowledge to overcome poorly documented legacy systems. In this way, we rebuilt a financial transaction system in just 10 months.
And we have the same wow-effect when building apps from scratch. We once had a customer, a Dutch insurance company who wanted to build a car insurance app that allowed customers that rented a car for, let’s say, three days, to have insurance for those three days only. We built a prototype in an hour and a half, and they immediately asked us if we could put it in production.
Low-code has definitely brought some significant changes to our way of working. We’re still agile, but with speed. This is how we’re enabling our customers' digital transformation and creating competitiveness.