Ditching DevOps for Low-Code

I’ve worked in software development and delivery most of my career. As a consultant, developer, development manager, even software architect, product owner, and project manager - I’ve seen a lot. 

Not long ago, I made the shift from software development for companies to software development product companies - helping organizations on their software journey overcome their challenges with our products.

Most recently, I worked at a great company focused on the DevOps space. I really enjoy DevOps. DevOps solves many problems with traditional application development and delivery, automating steps companies traditionally do manually. 

But something was gnawing at me: and I decided to make a change.

Why, you ask? DevOps and traditional application delivery more broadly just felt really, really complicated.

What do you mean complicated?

Take a look at this graph (and the many others like it):

As you can see, there are dozens of categories, sub-categories, off-shoots, and integration points. It's hard enough to know what the categories mean. You need to pick a tool in every segment: source control, binary repository, software configuration management, continuous integration, deployment tool, issue tracking, ChatOps, requirements management, dependency management, infrastructure as a service... you get the idea.

Choose wisely: an outage or failure in just one of these tools can bring your development process to its knees.

All of a sudden you’re spending more time on the tools in your pipeline than you are pushing innovative products through the pipeline. And the time isn’t just spent acquiring the tools, but configuring and integrating them. In most cases, each tool is made by a different vendor who doesn’t always have a motivation to make sure their tool integrate well with others. 

My theory? Most applications don’t warrant the level of complexity implied by the traditional DevOps approach. Put simply: it’s just not worth it. Literally.

So first I thought some consolidation is due in the space. Fewer vendors filling more of the boxes. I considered another great company, one I really respect a ton that has a vision to simplify software development by consolidating some of the top needs (source control, issue tracking, continuous integration). But I decided consolidation alone wasn’t aggressive enough.

What about a different approach altogether?

What would be better than consolidating some of the tools in a traditional application development paradigm? How about consolidating all of them, from IaaS to software framework? And accelerating the application creation process by promoting more reuse along the way.

Ditching DevOps for Low-Code

I decided to join the industry leader in the Low-Code space, OutSystems - and the best part of OutSystems Low-Code Platform? Many of the traditional DevOps tools are built right in. 

I know what you’re thinking: “Riiiight; they’re all built in. But are they as feature-rich as the tools from the graphic?" No. Probably not. Does it matter? My theory: in almost all cases, no.

Think of your application delivery toolchain like a grill. You need a grill to make some nice, chargrilled burgers for your customers to keep them coming back (beef, turkey, veggie, tofurgers, whatever your customers want :).

If you hand pick every part of your grill to make burgers, will the grill parts be better? Maybe. But are you going to order every part correctly? Probably not. And assemble it correctly? Definitely not. Remember: in the app delivery space, there are tons of different vendors. Imagine hand-ordering parts for your grill from different companies! 

Most importantly: will the burgers be better? Arguably not - definitely not if they never get done.

How long will all this take? At what cost? 

The process of building software today is like ordering parts for a grill one at a time from different companies, when you really just needed to make a burger.

You needed to make some burgers; now you're stuck on the phone re-ordering parts from two different vendors to get the grill started. Most companies I know don’t want to make grills. They’ve got burgers to make.

Enough about grills. There’s more upside to buying a more complete development platform: with OutSystems, we include features you may not have had the time to select (and install, configure, test, etc.) - and they’re already assembled. Automated deployment? Got it. In-app feedback? We have it. Enterprise app distribution? Check. Environment lifecycle management? Yep.

This “pre-assembled” aspect of OutSystems Low-Code platform alone will save you a ton of time and allow you to start shipping apps faster. You'll also get better coverage across the traditional DevOps needs than you’d get on your own without investing a TON of time and money. And we’re not even talking about the ways Low-Code tools like OutSystems are hyper-focused on productivity and optimizing reuse.

Why OutSystems?

My grilling analogy makes clear why I ditched DevOps for Low-Code, but why OutSystems?

• Leadership: the OutSystems management team, including our CEO Paulo Rosado, are recognized in the industry for their leadership.
• Product: OutSystems' product is mature and robust, recognized by Forester as the #1 Low-Code platform.
• Opportunity: Forrester predicts the low-code market will exceed $15 billion by 2020 and OutSystems is well positioned to lead the pack.
• Community: OutSystems community members are passionate and active; there are over 1,200 reusable open source components in the OutSystems Forge.

You may not have heard of Low-Code or OutSystems before today — but you have now! And you can expect to hear more and more about us.

Are you ready to join the Low-Code revolution either for your application development needs (burgers, anyone? :) or Careers at OutSystems? Get in touch.