devopsy.kinsta.cloud

Category: Low-Code/No-Code

Future of DevOps: Trends to Watch

Technology is transforming every aspect of industry, and digitalization and automation have flourished in the past few years. DevOps has established itself as an indispensable software development methodology for successful digital transformation.

According to a recent market survey, the DevOps market will exceed $20 billion by 2026, growing at a CAGR of 24.7% from 2019 to 2026. DevOps has facilitated rapid and dependable software development, delivery, improved quality and higher customer satisfaction.

DevOps, too, is continuously evolving to meet the changing demands of the corporate environment. Let’s look at the future of DevOps and the trends you should expect to see.

Serverless Computing

DevOps teams will see a rise in the adoption of serverless architecture, mainly because of the massive capital and operational costs of server infrastructure. Numerous DevOps groups are working with modular components offering an overview of the pipeline. Moving these modular components to serverless architecture will empower groups to mitigate a few pieces of errands identified with pipeline architecture and focus on deployment and development of the product.

Serverless computing streamlines overall DevOps operations, including the complete software life cycle, from development to deployment, testing and maintenance in one place. Also, serverless computing reduces the developer’s workload by taking care of server maintenance, such as cloud monitoring and system updates. Other prime USPs include flexibility, reliability, speed and cost-efficiency.

Microservices Architecture

Microservices architecture has been gaining popularity as an alternative to traditional monolithic architecture in the IT industry, and this trend is expected to continue. Microservices architecture is a pattern of organizing computer systems into segments that can scale on demand. A microservices architecture pattern is the next evolution of service-oriented architecture (SOA) that structures an application as a collection of coupled services. If one piece of the application fails, microservices make it easy to identify and contain the issue without disrupting the whole application.

DevOps and microservices architecture enable decentralized teams to innovate rapidly, maintain control over their tech stack and standards, track performance metrics, supervise the development and release cycles and reduce overall consumption time by achieving shorter software release intervals.

Low-Code/No-Code Applications and Platforms

To keep up with the demand for new applications and features, many organizations have turned to low-code/no-code development to deploy applications swiftly. Adopting a low-code approach with DevOps is a game-changer. It enables developers to experience higher agility and gives the organization a competitive advantage in the fast-paced, demanding software market.

Low-code applications allow non-technical ‘citizen developers’ to contribute to software development with the help of visual interface integration. In addition to end users, developers and DevOps engineers are set to play a crucial role in this trend, using low-code platforms and tools that offer drag-and-drop elements and other extensions. These low-code application development tools support every aspect of software development, including app ideation, analysis, software design, code development, quality assurance, deployment and documentation.

DevSecOps

Many large enterprises are integrating and automating security into DevOps processes. The transformation from DevOps to DevSecOps is expected to gain even more momentum in the future. According to a forecast, the DevOps market size is expected to reach $5.9 billion by 2023 at a CAGR of 31.2% during the forecast period.

More companies will embed security controls earlier in the software development cycle to ensure application security. Tools and frameworks will simply integrate with CI/CD pipelines and testing tools will see a rise in 2022. DevSecOps empowers developers to consistently track, monitor and remediate security defects during the various stages of development while improving the speed of delivery and quality.

Kubernetes and GitOps

Kubernetes is an open source container orchestration platform emerging as an infrastructure trend on the operations side. Kubernetes will expand further into the software development space in 2022 and beyond. It will ease the task of starting a local Kubernetes cluster on a developer’s machine. Kubernetes security is expected to take center stage as well, through infrastructure-as-code (IaC) scanning.

GitOps is a Kubernetes-related infrastructure trend that allows developers and IT operators to use Git to manage clusters and deliver efficient, secure applications without misconfigurations. It automates releasing incremental updates, and consistent delivery will enable developers to build, test and deploy software rapidly.

AI and ML

Artificial intelligence and machine learning have already transformed the way businesses operate nowadays. In 2022, it is anticipated that AI/ML will further streamline and accelerate every phase of the SDLC. It enables DevOps teams to enhance their performance through intelligent automation, improving feedback and managing alerts.

Advanced analytical methods like predictive analytics are becoming increasingly important as the market evolves. AI can enable proactive investigation of the DevOps pipeline to identify problems and offer possible solutions. AI and ML integration also enable deep learning, data mining, statistics and modeling, becoming an integral part of your business’ workflow.

Conclusion

DevOps continues to evolve and pivot to drive significant IT transformations that directly bolster business goals and objectives. It will assist in enhancing the company’s ability to design, produce, launch and maintain high-quality software solutions. The above trends will help organizations move rapidly beyond automation, focusing on continuously improving outcomes. These trends are catalysts for creating a regular and dependable release pipeline and building better communication between development, IT and business teams.

July 22, 2022
The Future of Low-Code Development

Fear of automation (automation anxiety) has existed since the 16^th century. It has been a major driver of negative attitudes toward technology and machines (also known as technophobia). With more sophisticated low-code and no-code development solutions on the horizon, even software developers face bouts of disquietude related to their job security.

While low-code solutions have the power to improve customer experiences rapidly by automating redundant business processes, can they replace developers altogether? The following guide will attempt to peer into the future of low-code development by analyzing current trends and upcoming advancements.

Understanding Low-Code Development’s Recent Popularity

Low-code describes tools, platforms, and other technologies that allow you to build applications with as little coding as possible. Many of these platforms let you build entire web or phone applications through a drag-and-drop interface.

However, most small-to-medium size enterprises use these low-code tools to build simple background services to help optimize employee workflows. Recently, we have seen the popularity of rapid software development and deployment methodologies such as Agile and DevOps.

Many businesses have begun to integrate cross-functional collaboration models to optimize these pipelines. This has spawned multidisciplinary development teams known as fusion teams. These teams often consist of a mixture of software developers and non-tech business analysts who may not have coding experience.

IT leaders have found that the best way to bridge the gap between fusion team members is through low-code development platforms. Many of these platforms have begun to roll out new features to facilitate smooth collaboration between fusion teams as well.

Low-code platforms have always been used to create rudimentary solutions to urgent business problems. However, recently, they have advanced to address new problem domains.

A Brief History of Low-Code

Microsoft Access is one of the earliest examples of a commercial no-code/low-code tool. It allows you to build databases using forms and other graphical tools. The tool was originally intended to help users build small personal databases without using SQL (or Transact-SQL). However, workers began sharing these Access-created databases among their peers.

Eventually, large companies would start building entire workflows around these databases. There are many reasons why this may become a liability for these companies. Using a fully specialized relational database management system such as Microsoft SQL or MySQL is the safer bet.

Organizations must still use the services of experienced software developers and database administrators. These professionals can ensure that databases are secure and compliant with standards such as HIPAA and the EU’s General Data Protection Regulation (GDPR).

Thus, despite Microsoft Access allowing non-technical users to create databases without any knowledge of SQL, programmers were still required to connect the dots. Low-code tools such as Access allowed business users to develop concepts and prove markets before bringing in developers to expand on the core ideas.

Developers would then remodel the data (for optimization) and build applications around these Access databases.

The Current State of Low-Code Development

Today, more involved and sophisticated low-code development platforms (LCDPs) can be used to build desktop and mobile apps. We have seen low-code tools empowered by cloud-native SaaS applications, allowing users to build scalable architectures easily. These LCDPs can allow you to build custom mobile, desktop and web apps that can satisfy advanced use cases such as accepting payments or simple ones such as restricting access to certain content.

A software developer’s focus is to write code; that is their daily life. Thus, they may not have the on-the-job experience of the professionals or the use cases they write applications for. Who is more equipped to write robust medical apps than doctors and other medical staff? Who can fully sympathize with the plight of construction workers better than other construction workers?

That’s why the “citizen developers” movement has become so prominent. In fact, research conducted by Gartner revealed that over 41% of non-IT professionals customize or build their own software solutions to address business problems. Despite these statistics, businesses still need the input of developers. The problem domain has just evolved.

Where Do We Go from Here?

As sophisticated as LCDP and NCDP tools are becoming, they still have their limitations. In the future, businesses will be able to address these limitations in a couple of ways.

Artificial Intelligence and Machine Learning

Machine learning and artificial intelligence will be highly influential in the direction of low-code/no-code technology. Platforms like Microsoft’s AI builder already provide a low-code approach to building machine learning-powered automated software. You can then integrate these template-built ML models into your business applications or software stack.

We have seen how they have been used in medical and veterinary communication software to automate scheduling and communications. Thus, LCDPs can be used to make machine learning more accessible to non-coders.

However, machine learning can also make low-code platforms more effective. For instance, ML-powered data mining can be used to find the latest updates and the best solutions to business problems. It will allow NCDPs/LCDPs to provide more relevant and tailor-made suggestions to citizen developers.

In the future, it may be possible to build an automation process or application by simply supplying a specification through text, a UML use-case diagram, or speech. This allows for more flexible project composition options.

Improving the user experience is one of the most important priorities of IT leaders today. Machine learning paired with low-code will help businesses rapidly address these challenges.

Hiring Professional Developers to Overcome Low-Code’s Limitations

Eventually, business owners and non-IT staff run into problems that low-code solutions simply cannot address–at least not out of the box. In these situations, it would be best to hire a developer.

Enterprises will still require the services of professional application developers for more involved and complicated use cases. This will be the case even with machine learning and artificial intelligence powering future low-code solutions.

The truth is while business users may hold a deeper understanding of the relationship between business objects, only trained and experienced software developers can efficiently implement these concepts in code.

Thus, no-code will not bring about the extinction of the professional developer. Instead, it will facilitate improved collaborations between citizen developers and professional developers. This is especially important for medium to complex projects.

Security Must be Addressed

The industry’s recent trends and heavy emphasis on cybersecurity and network security are another reason why software developers will not become obsolete. For instance, many developers have found that they need to pay more attention to API security, thanks to uncovered vulnerabilities in APIs such as Log4j.

As such, they must integrate security earlier in the development pipeline to prevent any possible data leaks and breaches. Most low-code tools use APIs to build applications. Unfortunately, citizen developers cannot secure their applications the same way professional application developers can. Even as LCDPs receive security updates regularly, it may not be enough to protect business applications from future cyberattacks.

Again, this is why collaboration between citizen and professional developers is so important. Only the latter can truly ensure that business software is secured appropriately.

Better Collaboration is the Future of Low-Code

Future no-code and low-code tools must be able to easily promote collaboration between professional developers and non-developers. These platforms should provide relatively easy and secure ways for developers to access code to modify and extend it as freely as possible.

In most cases, software developers already have frameworks and tools that they prefer to use for their workflows. From IDEs, CI/CD automation to testing software; low-code platforms should be able to plug into or interface with these established environments and tools.

Again, this attribute is extremely important, especially with the sweeping popularity of development and delivery methodologies such as Agile and DevOps. These techniques and models require smooth collaborative action between cross-functional teams. The more flexible an LCDP, the better. We’ve seen how unnecessary programming constraints of modern LCDPs can obstruct progress in cross-functional settings. These shortcomings must be addressed. If LCDPs/NCDPs fail to do this, their existence in the market will most likely be short-lived.

Conclusion

We do not see low-code platforms completely deprecating professional software developers in the near (or far) future. However, they will change how developers build software. Business and job requirements for programmers will evolve too as low-code has the potential to improve collaboration between developers and non-developers.

Citizen developers can use low-code tools to model what they want for their final product before allowing experienced developers to expand and build upon these ideas. Thus, these low-code development platforms must be accessible and easier to use for citizen developers but less restrictive and more flexible for professional application developers. They must allow professional devs to code more freely. This will be the focus of low-code platform developers in the coming years.

July 15, 2022
ERP Modernization: How Devs Can Help Companies Innovate

In this post-pandemic world, large enterprises are looking to streamline and improve business processes within a storm of marketplace constraints. Companies in asset-heavy industries such as oil and gas, energy, retail, or distribution and logistics have especially been working to reconfigure their supply chain processes to better manage inventory and operations. The focus in the market has shifted from supply chain optimization to supply chain resiliency, creating efficiencies that will help them best survive current delays and rising costs.

Breaking Barriers and Addressing the Talent Shortage

The question is not simply whether companies need to modernize their business applications to increase efficiency and lower costs, but how to accomplish a necessary modernization in the midst of barriers like rising costs, supply chain disruptions and a severe shortage of developer talent. Developers and DevOps teams need to find ways to do more with less.

The reimagining of business processes is an excellent strategy to reduce overhead and allow companies to become nimbler and more efficient, consequently helping them preserve or improve marketshare. Many large enterprises work in environments that use enterprise resource planning (ERP) software; systems that, over the years, have been subject to ongoing upgrades, patches and redesigns by developers and IT managers. This creates technical debt, which makes it difficult for many of these large-scale companies to migrate their business applications to cloud-based systems.

Many of these ERP-based companies are facing pressure to update to more modern, cloud-based versions of their ERP platforms. But they must run a gauntlet to modernize their legacy applications. In a sense, companies that maintain these complex ERP-based systems find the environments are like “golden handcuffs.” They have become so complicated over time that they restrain IT departments’ innovation efforts, hindering their ability to create supply chain resiliency when it is most needed.

To make matters more difficult, the current market is facing a global shortage of human resources required to get the job of digital transformation and application modernization done, including skilled ERP developers—especially those skilled in more antiquated languages like ABAP. Incoming developer talent is often trained in more contemporary languages like Java, Steampunk and Python. These graduates have their pick of opportunities and gravitate to companies that already work in these newer programming environments.

ERP migrations can be hampered by complex, customized systems developed by high-priced, silo-skilled programmers. Many enterprise leaders have a great desire to break out of these restrictions and modernize legacy applications with greater speed and at lower cost, and they need to do so with minimal downtime and disruption.

Leverage Low-Code Solutions to Modernize

In a 2022 report on application development strategies, industry analyst Deepa Salem interviewed enterprise companies that used sophisticated SAP-based ERP solutions about their approach to software modernization strategies. More than 80% of respondents said they planned to upgrade their business applications in conjunction with a major migration of their ERP software platform to the latest, cloud-based version.

This tactic of implementing a new applications strategy in coordination with a major refresh is not surprising and presents an opportunity for developers to help these companies “clean house,” reducing the technical debt of their legacy environments at this well-timed juncture.

As an analogy, think about how people typically move to a new residence. Homeowners sift through their accumulated possessions and identify what’s no longer needed. They pack what is still valuable and essential. A low-code application process can help clean up existing ERP environments prior to migration, reducing complexity and long-accumulated technical debt while leveraging the system’s unique business intelligence. The tribal knowledge inherent in any legacy system is critical to retaining market differentiation.

With so much at stake, IT departments and developers should give serious consideration to using pre-built, customizable business applications, efficiently and rapidly created through a low-code development process. Deployment-ready solutions can help developers move forward with modernization projects that have been hampered or shelved due to a lack of talent to implement those jobs. They can accomplish more with less.

With the right approach, ERP-based environments can be reconfigured to quickly establish more agile, streamlined and cost-effective business applications. Developers have a unique opportunity to help enterprises keep what sets them apart from the competition and surrender what no longer serves them. In this climate, this is not a nicety for enterprise customers. It’s about resilience—and even survival.

July 8, 2022
TechStrongCon: Time to Build an Army of Citizen Developers

DevOps teams need to start drafting a strategy to support what will soon become an army of citizen developers.

Speaking at the virtual TechStrongCon event, JP Morgenthal, global director for modern applications development at DXC Technology, told conference attendees that the time to build an army of citizen developers is now.

Citizen developers are typically end users that have developed enough expertise to build an application using low-code or no-code tools. Most organizations don’t have enough professional developers to address their application development backlogs, so it’s imperative that they enable end users to build applications, noted Morgenthal.

Those citizen developers, however, need to be supported by DevOps teams to ensure guardrails are in place for building secure applications that scale. In addition, DevOps involvement also reduces the friction that a citizen developer will most certainly encounter when building an application, he added. “DevOps is fundamental, “ said Morgenthal. “We need to invest in it heavily.”

Otherwise, citizen developers—who typically have other tasks that require their attention—will simply abandon their application development efforts, he noted. “This is not their primary task,” said Morgenthal. “They are going to need to be nurtured.”

Most professional developers are focused on applications that are systems of record. The problem is that there simply are not enough of them to build necessary applications to drive systems of engagement, noted Morgenthal.

That increased reliance on citizen developers is, in fact, part of a larger wave of democratization of IT in which individuals that don’t have advanced technology degrees take advantage of automation to build and deploy applications, he added.

Organizations, however, run into issues when they fail to test those applications, make sure that configurations are not manually changed or don’t address the technical debt that inevitably accrues over time, said Morgenthal.

Burnout can also become an issue, so Morgenthal said organizations need to make sure that agile development practices are used to first create a minimally viable product (MVP) and then plan development sprints to update and maintain it.

Finally, there also needs to be a plan in place for shifting responsibility for the application to someone else when the individual that created it eventually leaves the organization, he added.

Citizen developers, of course, are not the only ones using low-code and no-code tools. Many professional developers are using those same tools to build applications faster. In fact, it’s not clear how many end users have the skills required to successfully build applications, even though low-code and no-code tools automate much of the process. One way or another, many professional developers are now also collaborating more frequently with end users to build applications using low-code/no-code tools that make it easier for end users to, at the very least, describe the workflow of the application they want to build and deploy.

Regardless of who builds the application, it’s a given that a lot more code will be moving through DevOps pipelines in the months and years ahead. DevOps teams, as a result, will inevitably need to revisit workflows and platforms to continuously update and maintain those applications at scale.

July 1, 2022
Salesforce Adds RPA Bots to MuleSoft Integration Platform

Salesforce today announced that it is now using robotic process automation (RPA) to connect disparate data via a no-code tool developed by its MuleSoft unit.

Shaun Clowes, chief product officer for MuleSoft, said bots created using an RPA-infused integration platform can now automate much of the effort previously required to integrate data residing in different systems. Salesforce acquired MuleSoft in 2018 and, since then, has been working to make the platform for integrating application programming interfaces (APIs) a core element of its business process workflow tools.

The news was announced at the MuleSoft CONNECT 2022 conference. The overall goal is to employ RPA and no-code tools to accelerate digital business transformation initiatives without writing code, noted Clowes. Overall, Salesforce claimed its customers are running 4.8 billion MuleSoft transactions daily, resulting in a 74% decrease in operational costs and a reduction of more than 100 billion hours of work every month, using Salesforce Flow tools that are integrated with the MuleSoft integration platform.

In theory, no-code tools that integrate disparate data sources can be used by professional and so-called citizen developers alike. That capability should reduce the time and effort required to create those integrations. A recent survey conducted by Salesforce found nearly 96% of respondents said that modifying and rebuilding automation is a challenge as systems and business requirements change. In addition, four out of five respondents noted that restructuring existing application and data landscapes to support automation would likely compound their organization’s technical debt.

More than half of respondents (53%) said they are using integration and API management capabilities to some extent, with 44% employing those capabilities to drive business process automation initiatives. A full 80% said they are working toward putting hyperautomation on their technology roadmap within the next 24 months.

Of course, the MuleSoft platform can be employed beyond the portfolio of software-as-a-service (SaaS) applications provided by Salesforce. However, it’s also become apparent that more organizations are building and deploying custom applications on top of a range of SaaS applications in addition to building and deploying applications written in procedural code that might be running in the cloud or in an on-premises IT environment.

It will be up to each IT organization to determine how much they need no-code integrations as part of a larger DevOps workflow, but as it becomes easier to create integrations using RPA tools their numbers should increase. The impact all those integrations will have on DevOps pipelines remains to be seen, as well. Many organizations will need to revisit their DevOps workflows as the number of application development projects being simultaneously launched continues to increase.

In the meantime, it’s clear that no-code/low-code tools infused with RPA capabilities will empower more end users. That shift will have a profound impact on DevOps teams, as the sheer volume of code and associated integrations increases. The challenge, of course, will be finding a way to make sure that the integrations created are secure and that they can actually scale as more data sources are added.

June 29, 2022
AppSmith Adds Git Support to Low-Code App Dev Framework

AppSmith has added support for Git repositories to an open source framework for building custom applications using a low-code platform based on the JavaScript programming language.

Rishabh Kaul, head of marketing for AppSmith, said the Git support will make it simpler for developers to manage version control as they iteratively build applications using a set of graphical widgets provided by AppSmith.

AppSmith is used primarily by developers to build internal applications that automate a specific task or workflow. Support for Git makes it possible for multiple developers to more easily collaborate as they add work to a Git branch and make requests within the context of a continuous integration/continuous delivery (CI/CD) pipeline.

That also makes it simpler to test applications and roll back to a previous version in the event something should go wrong, said Kaul.

The Community Edition of AppSmith will make it possible to connect to unlimited public repositories and up to three private ones before requiring developers to upgrade.

In recent years, use of low-code tools has increased dramatically as organizations embrace tools that enable them to build applications faster. Not every application requires developers to employ tools for working with procedural code. There are typically hundreds of use cases where an organization could build and deploy an application that would eliminate the need for an internal team to license yet another packaged application.

In general, AppSmith and other open source tool and framework providers are betting that, as the economy continues to shrink, the adoption of these tools will increase as organizations continue to become more sensitive to costs. That approach will allow them to continue to provide applications tailored to automate specific tasks.

The challenge, of course, is that as the number of applications being built and deployed steadily increases, the DevOps workflows that regularly update, secure and maintain those applications become much more challenging.

It’s not clear what percentage of applications are now being built using some type of low-code tool. However, the overall size of organizations’ application portfolio is generally much higher than it was prior to the pandemic. Many of those applications are driving digital business processes intended to make the workforce more efficient at a time when many employees continue to work from home.

Less clear, however, is how many new applications are being built by so-called citizen developers. One way or another, however, it’s becoming easier for end users that have some basic software understanding to build applications. Inevitably, those application development efforts will also need to be integrated within the context of a DevOps workflow.

Regardless of how an individual DevOps team may view low-code tools, they have permanently altered the application development landscape. The issue is no longer whether low-code tools will be used by developers but rather to what extent. In the meantime, DevOps teams would be well advised to review just how extensible their existing pipelines need to become.

June 13, 2022
Catchpoint Enables Experimentation by Automating Web App Testing

Catchpoint this week expanded its open source WebPageTest performance testing suite of tools to enable IT teams to run instant tests that surface suggestions for improving overall web application and site performance.

In addition, Catchpoint is now providing support for private tests, bulk tests and priority testing capabilities within the WebPageTest tool suite.

Tim Kadlec, director of engineering for WebPageTest, said the goal is to make it easier for both developers and DevOps teams to experiment with how changes to applications and websites could improve performance using a capability that has now been added to the core suite.

Identifying opportunities to improve performance typically requires tediously constructing manual tests over a period of weeks, noted Kadlec. Much of that effort is experimental in the sense that no one knows for sure if the tests being constructed will have a material impact on performance.

The Opportunities and Experiments capability provides teams with a low-code tool for building tests based on a set of best practices that Catchpoint has defined. That approach makes it simpler to automatically generate and test tweaks that, for example, eliminate blocking scripts, optimize image rendering and minimize layout shifts. The result is optimization tests that show how their applications and websites could benefit from specific, actionable improvements without having to change any of the code that has already been deployed, said Kadlec.

That’s a critical capability because it will encourage a level of experimentation that previously IT teams shied away from, simply because the amount of effort required to achieve an uncertain outcome was too high.

It’s not precisely clear who is conducting these types of tests, as more responsibility for testing applications continues to shift left toward developers. The latest additions to WebPageTest make it easier for developers to conduct those tests without necessarily requiring help from a DevOps team, noted Kadlec.

While there has always been a tremendous amount of focus on web application and site performance, the attention level has risen across organizations in the digital business transformation era. Many of the processes being implemented via web applications are extremely latency-sensitive. As more of those applications become routinely tested, the overall level of application performance should steadily improve.

At the same time, the number of web applications and websites that most organizations are supporting also continues to expand. Most of those organizations are looking for ways to test applications without necessarily having to expand the size of the testing team or significantly increase the amount of time spent on testing.

Regardless of the approach, it is apparent that testing is becoming more automated. The goal is not so much to eliminate the need for dedicated testing teams, but reduce the number of rote tasks that contribute to test avoidance in the interest of saving time. In theory, the more tests run—and the earlier they are run—the fewer issues that DevOps teams will need to deal with later.

June 2, 2022
Survey Surfaces Challenges Ahead on National DevOps Day

A survey published today for National DevOps Day found nearly two-thirds (63%) have seen an increase in the frequency of service incidents that have affected their customers over the course of the last 14 months.

The survey polled 1,046 engineering, IT operations, DevOps and site reliability engineering (SRE) professionals at organizations with more than 300 employees. The research was conducted by Transposit, a provider of a platform for connecting DevOps workflows, and found well over half (58%) of respondents reported the cost of downtime for their organization could be, on average, up to $499,999 per hour, with 40% of respondents noting that the cost of downtime has increased in the last year.

Respondents said the top contributing factors to the increase in service incidents were digital transformation (61%), new product rollouts or product updates (55%) and methods and tools for collaboration that do not adequately support their team working remotely (49%). A full 90% of respondents reported there has been an increased focus on digital transformation during the last year with 73% having expanded the technology stack they support. More than half (55%) have increased the size of their DevOps teams.

Overall, 46% of organizations reported they have experienced between six and 19 major incidents over the course of the last 12 months. More than half (53%) also reported an increase in the amount of time it takes to resolve incidents over the course of the last year, even though three-quarters of respondents (75%) said their organization increased their adoption of SRE practices in the last 12 months. Additionally, 65.1% of those organizations planned to hire site reliability engineers in the next 12 months. However, only just over a third of those respondents said their organization planned to expand their SRE efforts in 2022.

A full 83% said up to 50% of their engineering operations processes are automated, but over half of the respondents that use SRE practices noted they still manually enter data into an IT service management (ITSM) application or other system-of-record to keep track of actions that were taken by humans during the resolution of an incident. Nearly two-thirds said their approach to automation was incremental, in which they begin by codifying processes and worked up to more advanced, fully automated scenarios.

The top three tasks respondents would like to automate were service requests (53%), change requests (43%) and user provisioning (40%).The top barriers to implementing automation were cited as inadequate documentation of institutional knowledge and existing processes (56%), lack of clarity about what to automate (55%) and an inability to share knowledge (52%).

Investments to improve their incident management processes over the next 12 months are focused on automation tools or applications (48%), communications/collaboration tools or applications (42%) and integration tools or applications (41%). Only a quarter (25%) said their tools are integrated through one tool or platform.

Lack of unified communication with teammates (45%), processes that have changed or are harder to follow while working remotely (42%) and lack of visibility into dependencies and what teams or people are responsible for the code or infrastructure (38%) are all cited as reasons why serviced requests are now more complex.

Transposit CEO Divanny Lamas said despite all the challenges facing DevOps teams, it’s fortunate that advances in low-code automation are making it simpler to more widely implement DevOps best practices. The challenge is finding a way to implement those best practices faster at a time when IT environments are becoming more complex.

May 24, 2022
The Future of Low-Code Development
The days when IT teams relied on clunky software development processes and labor-intensive hand-coding to build tangible, reliable and modern applications are coming to an end. With the rise of new automation technology, rapidly rising expectations and demands from innovation-craving customers and end users and a shortage of developers, the software sector has been forced to seek alternative approaches to not only deliver their services and products but to also remain digitally-current. Now, overcoming this challenge is possible with low-code development platforms.

What is Low-Code Development and Why all the Fuss?

Low-code development is a software development practice that empowers digital product teams and citizen developers to build apps without time-consuming hand-coding. In general, a typical low-code platform includes a visual integrated development environment (IDE), connectors to various backends or services, an application life cycle manager and an integrated design-to-code system.

With these features and attributes, low-code platforms:
- Abstract away the code behind complex commands and actions
- Streamline how projects are being innovated and distributed in the span of weeks, not months
- Enable citizen developers to build apps
These tools are so effective because they break the mold and automate the app development cycle by providing reusable building blocks. These building blocks can easily be assembled into an entire app, allowing both experienced and beginner technical minds to handle a bigger volume of projects faster than ever. This flexibility is handy, especially when the digital world expects over 500 million apps and digital services to be built and deployed by the end of 2023, according to IDC FutureScape. That is more than all of the software solutions created in the last four decades.

A report by Gartner forecasts that by 2024, low-code adoption will be so widespread that 75% of the software solutions built around the world will be made with the help of such tools. While these tools won’t entirely replace traditional software development, they deliver a contemporary, simpler and faster approach to building apps.

Benefits of Low-Code Development

Whether it is automating individual manual tasks, eliminating old development models like waterfall methodology or making it easier for a tech newbie to build a prototype or a flexible app, low-code development has many benefits.

The benefits of low-code software include:

Innovative projects can be assembled by a non-technical audience

Low-code app builders are game-changers. The need for experienced coders is reduced as this type of tool provides the necessary components and building blocks for non-technical audiences to be involved in full-cycle app development. Another recent Gartner report said that 80% of technology products and services will be created by people outside of tech-driven fields by 2024. And in times when the demand for commercial software, new progressive solutions and skilled developers exceeds the supply, low-code tools are a perfect fit for citizen developers, designers, professional developers, non-technical stakeholders and others.

Velocity and optimized development cost

Today, speed is everything. IT businesses and clients require their software to be built within short timeframes and within a strict budget. Legacy systems need rapid modernization without a big investment. One of the greatest advantages of low-code tools is that they let people build at scale without incurring heavy costs or consuming too much time. Automation apps, mission-critical systems and mobile applications can all be created with low-code software.

Reinventing traditional processes and reshaping how software is built

Using these automation tools, you don’t have to worry about HTML/CSS, scalability, coding rules, page layout, branding or screen sizes. As mentioned above, some low-code development platforms come with a system that covers everything from design to code and generates production-ready code in the end. Designers and developers come together to use a single platform that simultaneously:
- Allows them to create solutions that are easy to maintain and that scale on cloud-native architecture
- Modernizes and facilitates their work
- Improves productivity and collaboration
- Fits their workflow and skills
Low-code/no-code tools are quickly becoming the next prototyping tools in the enterprise—without needing the technical skills in traditional UX/visual designer-focused tooling. With low-code or no-code tools, screen design is typically done using drag-and-drop, WYSIWYG design-time experience; it’s usually as simple as making a PowerPoint deck. The main difference between this and a UX/visual design tool is that the low-code/no-code tool is building a running app in the background, with real code, connected data, real screen interactions and more. This means that any team member with an idea can express the design, not just a person who has access to a designer.

No special skills are needed to build something tangible and real—while at the same time going beyond what a mockup or prototype can deliver.

The future of tools in this space will include connectors and adapters to popular design tools, such as Sketch, Figma and Adobe XD. These connectors and adapters will enable digital product teams—designers and developers—to use a design process and then import designs, interactions, branding and themes into low-code tools, while still obtaining the considerable benefits of time and cost savings of not having to re-build screens that have already been designed pixel-perfect.
April 28, 2022
mabl Makes Move to Automate Accessibility Testing

mabl today made available in beta an automated accessibility testing capability that it added to its software-as-a-service (SaaS) platform for testing applications.

Dan Belcher, mabl co-founder, said given the increased accessibility requirements included in various compliance mandates, there is a greater need to address these issues as early as possible in the application development life cycle. Otherwise, organizations could find they are liable for failing to comply with accessibility requirements outlined in, for example, versions 2.0 and 2.1 of the Web Content Accessibility Guidelines (WCAG).

At the same time, providers of applications that don’t address accessibility are also likely to find themselves called out on public social media forums, noted Belcher. The damage to brand reputation can be considerable, he added.

The SaaS platform mabl created makes it possible to create reusable tests using a low-code engine dubbed axe-core. Those tests can then be inserted, as appropriate, into a DevOps workflow. That approach allows a dedicated testing team to create tests in a way that doesn’t need to occur on a DevOps platform, said Belcher.

Regardless of regulatory requirements, Belcher said there is a clear need to include end users with disabilities within a digital universe that continues to rapidly expand. Unfortunately, as a whole, the software industry is only just starting to make accessibility a first-class concern, he added.

The goal should be to enable fast feedback via accessibility regression tests that address, for example, contrast check, said Belcher. However, it’s not likely those tests are going to eliminate the need for periodic audits by accessibility subject matter experts as an application continues to evolve, he noted. Those reviews would address everything from the user interface to the overall performance impact, noted Belcher. It may possible, however, to one day address 50% of the accessibility issues identified in the WCAG guidelines via automation, he noted. Scanning code as it is being developed will prevent a backlog and a buildup of accessibility debt that would be much more costly to address after an application is deployed, added Belcher.

In general, Belcher said, it’s not likely automation is ever going to entirely eliminate the need for dedicated testing teams. Testing platforms such as mabl are designed to enable a finite testing resource to keep pace with an accelerated rate of application development, he added.

Accessibility is, for all intents and purposes, a subset of any comprehensive software quality review. The sooner development teams realize that fact the less likely they will find themselves apologizing in the future for not coming to that realization earlier.

April 27, 2022