devopsy.kinsta.cloud

Tag: No Code

Low-Code/No-Code in Microsoft 365: How Power Platform is Redefining Enterprise DevOps

Low-code and no-code platforms have moved well beyond their early perception as tools for lightweight departmental apps. Today, they play a strategic role in enterprise DevOps, helping organizations modernize legacy systems, automate business processes, and deliver solutions at a pace traditional development models often struggle to match.

Within the Microsoft ecosystem, the Power Platform — Power Apps, Power Automate, Power BI, and Dataverse — has emerged as a mature, enterprise-grade low-code framework. Deeply integrated with Microsoft 365, Azure, and security and governance services, Power Platform is redefining how organizations think about application development and operations.

Why Low Code/No Code Matters in Enterprise DevOps

Modern enterprises face mounting pressure to deliver faster while managing growing technical debt, resource constraints, and increasingly complex compliance requirements. Traditional development pipelines often result in long backlogs of automation and application requests, especially for internal business processes.

Low-code and no-code platforms address these challenges by reducing development cycles from months to days, enabling business users to participate in solution design, and allowing IT teams to focus on architecture, governance, and scalability. However, the true value of these platforms emerges only when they are implemented within a structured DevOps and governance framework — rather than as isolated shadow IT tools.

Power Platform as an Enterprise Application Framework

What differentiates Power Platform from many low-code tools is its enterprise foundation. It is not simply a rapid app builder, but a unified platform designed to support secure, scalable, and governed application development.

Power Apps enables teams to rapidly build business applications using visual design and declarative logic. These apps commonly support approval workflows, request systems, data entry, and mobile workforce scenarios. With Dataverse and SharePoint as underlying data sources, Power Apps supports structured data models, role-based access, and enterprise authentication.

Power Automate serves as the automation backbone of the platform. Organizations use it to orchestrate approvals, synchronize data across systems, integrate SaaS and legacy platforms, and implement robotic process automation where APIs are unavailable. From a DevOps perspective, Power Automate introduces event-driven automation that reduces manual intervention and improves reliability.

Power BI completes the loop by providing real-time visibility into operational performance. When combined with Power Apps and Power Automate, analytics move beyond reporting to drive immediate action, enabling data-informed decision-making across the organization.

Low Code and DevOps: Complementary, Not Competitive

A common misconception is that low-code platforms bypass DevOps practices. In reality, they extend DevOps into areas traditionally underserved by software engineering teams.

Enterprises increasingly apply CI/CD principles to Power Platform solutions by separating environments, packaging solutions, integrating source control through Azure DevOps or GitHub, and automating deployments. Environment variables and configuration management ensure consistency across development, test, and production environments.

Governance and security are first-class concerns. Power Platform integrates with Microsoft Entra ID, Conditional Access, Data Loss Prevention policies, and Microsoft Purview. These controls allow organizations to scale low-code adoption without compromising security, regulatory compliance, or data protection standards.

AI and Copilot: Accelerating Low-Code Development

The introduction of Microsoft Copilot represents a significant shift in how low-code solutions are created. Copilot enables natural language generation of apps and workflows, assists with formula creation, and accelerates onboarding for non-technical users.

Rather than replacing developers, Copilot acts as a productivity multiplier. Architects and engineers can focus on system design, governance, and optimization while business users contribute more effectively to solution creation.

Real-World Enterprise Impact

In large organizations, Power Platform is now used to automate procurement and finance workflows, modernize SharePoint-based legacy systems, streamline external user access, and deliver executive dashboards. When implemented with proper governance, these solutions evolve into long-term enterprise assets rather than short-lived departmental tools.

Challenges and Best Practices

Despite its advantages, low-code adoption introduces new challenges. Uncontrolled app sprawl, inconsistent data models, and a lack of lifecycle management can quickly erode value. Successful organizations establish clear governance models, define environment strategies, implement Centers of Excellence, and foster collaboration between IT and business teams.

Conclusion

Low-code and no-code platforms like Microsoft Power Platform are reshaping enterprise DevOps. When combined with cloud architecture, DevOps discipline, and AI-driven assistance, they enable organizations to deliver solutions faster without sacrificing control.

The future of software development is not about replacing engineers, but augmenting them. Power Platform exemplifies this evolution, bridging business needs and technical execution in a scalable, secure, and intelligent way.

May 21, 2026
Why Software Migrations Fail: It’s Not the Code
Engineers often overlook the human and organizational dimensions of software migrations. They typically perceive these projects as technical undertakings, but institutional knowledge, communication gaps, team morale and resistance to change can significantly influence timelines and outcomes. Examining common pitfalls, effective strategies and emerging trends reveals a comprehensive view of the migration process from a human-centered perspective.

Recent research continues to validate that delays in software migration are the rule rather than the exception. In a 2023 McKinsey & Company report, over 70% of large-scale digital transformations fell short of timeline or return on investment (ROI) expectations, with a lack of cross-functional alignment and insufficient change management cited as leading causes. Similarly, a 2024 Boston Consulting Group survey revealed that nearly half of global C-suite executives reported that over 30% of their organization’s technology development projects suffered delays or budget overruns.

Understanding Software Migrations as a Human-Centered Process

Software migration involves transitioning systems, applications, or infrastructure from one environment to another. These transitions may include moving from on-premises deployments to cloud platforms, retiring legacy systems in favor of modern stacks, or switching technology between vendors. Despite their technical appearance, such migrations cause ripple effects throughout organizational workflows and operations.

These migrations often require retraining end users, maintaining legacy systems during the transition and navigating competing priorities. The disruption can stall development cycles and introduce operational risk. Overlooked in most planning stages is how much these projects rely on people’s undocumented knowledge, assumptions and behavioral responses.

Human and Organizational Barriers That Derail Migration Efforts

Scope creep or technical hurdles are frequently blamed as the cause of migration delays, yet deeper analysis reveals that resistance to change and knowledge gaps within teams are often more significant obstacles. End users familiar with a particular interface or workflow may be reluctant to adopt a new one. Internally, this resistance is not always voiced directly but manifests as disengagement or low adoption rates. Business stakeholders, too, may not fully grasp the strategic rationale behind a migration effort. Executive alignment weakens when the justification isn’t well articulated and cross-departmental cooperation becomes harder to sustain.

Undocumented institutional knowledge is another persistent challenge. Many decisions about data structures, hard-coded values, or interface dependencies exist only in the minds of long-tenured employees. When these employees move on or get reassigned mid-project, teams can lose the rationale behind legacy implementations. This knowledge vacuum causes surprises during implementation, especially when hidden dependencies emerge.

Managing Mid-Migration Surprises and Mitigating Risk

No matter how well-scoped a project is, assumptions made by different teams often go unspoken. Teams often operate in silos, assuming shared understanding when none exists. This misalignment can result in components built on conflicting premises, only discovered during testing or go-live. Mid-migration surprises include unanticipated manual workarounds, deprecated features that remain mission-critical and inconsistent definitions of business logic across systems. Manual processes known only to a few employees become barriers when they cannot be replicated in the new environment and uncovering these issues late in the process leads to delays and rework.

Incorporating discovery sprints before execution has proven effective in managing these risks. These sprints create space to unearth undocumented logic, validate inter-team assumptions and highlight edge cases early. Including a buffer—typically 10–20% of the timeline—also reduces the risk of missed deadlines.

Strategies to Reduce Rework and Support Successful Transitions

While tooling plays a supporting role, successful migrations hinge on clear communication and iterative execution. Automated migration tools can minimize manual tasks and streamline repetitive processes, such as data copying or schema translation. Relying solely on automation overlooks the need for continuous stakeholder alignment, however.

Here are some ways to reduce rework:
- Cross-team workshops. Use workshops to identify assumptions early and establish shared understanding.
- Regular check-ins. Catch evolving issues before they escalate by employing check-ins throughout migration.
- Phased rollouts. Transitioning rollouts over time rather than all-at-once helps organizations validate changes incrementally and apply insights from one phase to the next.
Communication breakdowns lead to duplicate efforts, reactive firefighting and coordination overhead. Maintaining old and new systems requires continuous attention and introduces operational drag. Factoring in learning curves and user adaptation time into project schedules can help set more realistic expectations. Offering flexibility during migration is equally vital for maintaining morale and sustaining trust.

Future Trends and Measuring Human Impact

Recent innovations are changing the migration approach. AI-powered tools now enable faster and more accurate transformations. In one notable case, Airbnb completed a migration, estimated initially to take two years, in just six weeks using AI tooling. These platforms automate repetitive code translations and configuration tasks, reducing reliance on large teams while preserving accuracy.

Low-code and no-code migration platforms simplify transitions by offering visual interfaces and guided workflows. These innovations allow a broader set of employees to participate in the migration process, increasing organizational resilience.

While AI accelerates execution, it does not eliminate the need for human oversight. Engineers now spend less time on rote tasks and more on designing, monitoring and validating migration paths. Prompt engineering, anomaly detection and performance monitoring are emerging as core responsibilities in this new paradigm.

Tools like GitHub Copilot and Amazon CodeWhisperer are increasingly integrated into migration workflows to assist with repetitive coding tasks, generate test cases and validate syntax conversions. These tools reduce the cognitive load on developers and help teams move faster through lower-level tasks, freeing up human resources to focus on architecture decisions, validation and user-centric improvements.

Metrics That Reveal Human Impact

Quantifying the human side of migration is complex but not impossible. Several indicators can provide insight into where people are struggling and may need additional support:
- On-call ticket volume. A spike in support requests during the migration window often reflects friction points, such as unclear interfaces, poor documentation, or insufficient training.
- Employee satisfaction scores. More extensive morale trends can reveal team emotional fatigue or frustration. Measuring satisfaction at different stages of migration provides valuable feedback loops.
- Attrition rates. Higher turnover among technical staff or support teams may signal disengagement, burnout, or disillusionment with the process.
- User feedback on new systems. Capturing qualitative input from end users via surveys, interviews, or feature usage can help determine whether the migrated tools effectively serve their needs.
- Project timeline adherence. Deviations from planned schedules often point to organizational misalignment, unanticipated rework, or breakdowns in communication.
These metrics collectively paint a more nuanced picture than completion percentages or delivery milestones. They help teams identify where to adjust code, expectations, workflows and morale.

Redefining Successful Software Migration

Technical upgrades may motivate software migrations, but the real complexity lies in navigating organizational behavior, knowledge gaps and human responses to change. Recognizing this dimension transforms software migration planning and execution. It’s not enough to have the right tools—teams benefit by fostering alignment, surfacing assumptions early and communicating continuously.

The future of software migration lies not just in AI and automation, but in embracing the human elements that make these transitions sustainable. As platforms evolve, the ability to manage systems and people will be the defining skill of successful engineering leaders.

Disclaimer: The opinions expressed in this article are those of the author. They do not purport to reflect the views of his employer.
June 30, 2025
SmartBear Adds More Generative AI Testing Tools to Platform

SmartBear this week extended its efforts to bring generative artificial intelligence (AI) to its test automation portfolio to include test data and application programming interface (API) contracts.

This latest addition to the SmartBear HaloAI family of generative AI tools automates a set of manual tasks as part of a larger effort to reduce the labor required to test applications, by leveraging foundational large language models originally developed by Open AI.

Dan Faulkner, chief product officer at SmartBear, said the company has been working toward mastering techniques such as retrieval-augmented generation (RAG) to enable developers to use natural language to automatically create valid tests based on data collected via its platform. The goal is to increase the level of determinism that can be applied to testing using a generative AI platform that, by definition, provides a probabilistic approach to generating content and now synthetic data for testing, he noted.

SmartBear earlier this year acquired Reflect, a provider of a no-code testing platform for web applications that leverages generative AI, to jumpstart its efforts.

The AI Test Data Generation for the company’s TestComplete platform will be available in beta next month. AI-augmented contract testing for its PactFlow platform will be beta-tested from July through August. SmartBear last month added an AI tool for generating API tests that eliminates the need for developers to write and debug scripts.

In general, the usage of natural language will make application testing more accessible to application stakeholders who wish to participate in the application testing process, noted Faulkner.

Generative AI should also make it simpler to strike the right balance between shifting some testing responsibilities further left toward developers when appropriate and running tests that would be better suited to being conducted by DevOps engineers, he added.

Ultimately, organizations should be able to shift responsibility to testing both further left and right to improve the overall quality of the applications they deploy, noted Faulkner.

It’s still early days so far as the adoption of generative AI is concerned. However, it won’t be long before these tools are pervasively employed to not only generate code but also automate DevOps workflows. The next major challenge will be orchestrating all the AI assistants optimized to perform specific tasks, such as testing APIs that will soon be embedded into those workflows.

In the meantime, DevOps teams will need to determine to what degree they can extend their existing workflows in ways that incorporate AI assistants versus opting to replace their existing platforms. Regardless of approach, DevOps engineers will soon find they have access to a range of AI assistants trained to automate specific tasks that they will need to asynchronously orchestrate at very stages of a pipeline to enable organizations to deploy more software faster.

The challenge is the amount of software an organization deploys within the next few years is likely to far exceed the software they might have deployed in the past decade. The less that software is tested before being deployed, however, the more likely it becomes DevOps engineers will find themselves spending more time than ever troubleshooting applications long after they have been initially deployed.

June 21, 2024
No Country for No-Code: Are We Heading Towards a Wild West of Software Security?

Nearly everything we use is built on code, from cars to smart fridges to doorbells. In businesses, countless applications keep devices, workflows and operations running. So, when early no-code development platforms launched in 2010, promising more accessible application development for citizen developers, its success felt inevitable.

It’s hard to deny the success of no-code. These platforms flatten the learning curve for would-be developers, allowing organizations to innovate and automate with useful applications despite a developer skills shortage. Plus, the out-of-the-box applications offered by no-code platforms expedite the application development process in a world where speed-to-market is king. Last year, Forrester found that 87% of enterprise developers use low-code and no-code tools or platforms for at least some of their workload.

But functionality is not the only sign of success. Unintentionally, the same trends that pushed for application development to be democratized have led to a wild west of insecure applications and misconfigurations that expose a whole host of organizations to cyberthreats.

The Importance of Security

While these platforms democratize development, they must be used with caution. The OWASP Top 10 highlights factors such as misconfiguration and using vulnerable components as common security threats. Yet, a reliance on no-code development could introduce un-spotted vulnerabilities directly into an organization.

Forrester has long warned of the risk of no- and low-code, featuring the vulnerability in its predictions for the coming years. The spectrer of an untrained employee creating applications is especially alarming: These platforms empower employees with no application security knowledge to develop programs that security teams are often unaware of.

Organizations must gain real oversight into who is responsible for developing software, whether professional developers leveraging no-code platforms as tools, or citizen developers creating applications for smaller teams and projects. It is no secret that CVEs are rising sharply. They hit a record 28,092 last year and are projected to increase by 25% throughout 2024. Last December, Microsoft revealed a high-severity CVE that affected low-code and no-code users.

When businesses are facing a tide of new exploits each day, skills such as vulnerability detection and remediation are critical to any new software development project.

Software development needs to become more flexible in its roles, but never at the expense of security. By fostering a culture of “security by design” across the organization, security leaders can ensure that all roles in the software development lifecycle (SDLC) understand their responsibilities in their security posture — including citizen developers.

Empowering Human Intervention

Just one in five organizations are confident in their ability to detect a vulnerability before an application is released, according to Security Journey research, meaning that the security knowledge in most SLDCs is insufficient. Developers need to be trained to create secure software and to sniff out insecure code in the rest of the code base – responding and fixing it quickly – before it gets to production. Without this, application security and security teams are left with an unnecessary burden, which ultimately requires more time, expense, and potential for business risk. Securing vulnerabilities after the fact, through regular security scanning and patching, should not be the norm.

Instead, organizations have an opportunity to empower developers with security skills and knowledge throughout their careers. These skills allow them to deliver a higher quality of output and play a vital role in securing the organization itself. And yet, just one in three organizations (36%) train developers to write secure code, which ensures that software security starts at the end of the development process 64% of the time. The same goes for citizen developers, whose work often shows a passion for problem-solving and innovation that should be harnessed and supported with the right training.

A Problem for the Future

It would be reductive to suggest that software security risk is rising purely because of no-code and low-code platforms, or even that citizen developers are a majority contributor to CVEs. The very culture of software development has been forcing the industry down a path of speed and ease over security for almost two decades. The surge in AI-generated coding proves this more than anything.

So long as developers and the project managers above them are incentivized to move fast, each new solution will be valued based on its ability to create functional code quickly. This will be the case until security is made a priority by regulators and, importantly, by executives and the board.

The cultural disconnection at the heart of the software security crisis is human-made. No matter which tool is in the spotlight, building secure software will require human solutions. While large language models (LLMs) aren’t yet equipped to tackle the complex considerations that developers face daily, the biggest risk will come from complacency, overreliance and blind trust from their users. Human developers, equipped to perform rigorous code reviews and remediate any vulnerabilities they find, are central to the safe implementation of any of these technologies, whether no-code, low-code or AI-generated. Without this, the tools run the risk of introducing more vulnerabilities with less critical supervision.

No matter what tools arise, knowledgeable human users will always need to understand what the tool is providing and can act as a stopgap for quality and security.

May 14, 2024
The Rise of Low-Code/No-Code in DevOps

The ever-evolving landscape of technology has ushered in a paradigm shift in software development and deployment. One of the prominent trends gaining momentum is the integration of low-code/no-code platforms within the DevOps ecosystem. This article explores how these platforms are revolutionizing the way applications are developed, deployed and managed, fostering collaboration between developers and operations teams.

1. Democratizing Development:

Low-code/no-code platforms empower individuals with limited coding experience to actively participate in the application development process. This democratization of development accelerates the delivery of software by allowing business analysts, designers and other non-developers—sometimes referred to as citizen developers—to contribute directly to the creation of applications.

2. Accelerating Time-to-Market:

The traditional software development life cycle often involves lengthy coding processes, leading to delayed releases. Low-code/no-code platforms enable rapid prototyping and development through visual interfaces, significantly reducing the time required to bring applications from concept to production. This acceleration aligns with the principles of DevOps, promoting continuous delivery and faster time-to-market.

3. Enhancing Collaboration:

DevOps is all about breaking down silos and fostering collaboration between development and operations teams. Low-code/no-code platforms bridge the gap between these traditionally distinct roles by providing a common ground where both technical and non-technical stakeholders can collaborate seamlessly. This collaborative environment promotes better communication, understanding, and alignment of objectives.

4. Flexibility in Deployment:

Low-code/no-code solutions are designed to be platform-agnostic, allowing for the deployment of applications across various environments, including on-premises and cloud. This flexibility aligns with the DevOps principle of infrastructure-as-code (IaC), enabling teams to deploy and manage applications consistently across diverse infrastructures.

5. Reducing Dependency on Specialized Skills:

In a DevOps environment, reducing bottlenecks and dependencies on specific individuals or roles is crucial. Low-code/no-code platforms enable teams to be more self-sufficient, reducing the reliance on specialized coding skills or DevOps Training. This, in turn, contributes to a more resilient and adaptable DevOps culture.

6. Challenges and Considerations:

While the adoption of low-code/no-code in DevOps brings numerous benefits, it also introduces challenges. This section discusses considerations such as security, scalability and the potential need for customization beyond the platform’s capabilities.

7. Real-World Use Cases:

Explore real-world examples of organizations successfully incorporating low-code/no-code in their DevOps workflows. Highlight the positive outcomes, lessons learned, and the impact on their overall software development life cycle.

Conclusion:

The rise of low-code/no-code platforms in DevOps is reshaping the way software is developed and deployed. By fostering collaboration, accelerating development cycles, and reducing dependencies on specialized skills, these platforms align seamlessly with the principles of DevOps. As organizations continue to embrace this trend, the synergy between low-code/no-code and DevOps is set to redefine the future of application delivery.

March 29, 2024
Generative AI and Software Testing Tools to Manage Technical Debt

It is easy to take a pessimistic view of generative AI and large language models (LLMs), especially when a growing list of AI experts and public figures have voiced concern about their potential to lead to dire consequences—even to human extinction. But we must also consider how these same technologies might mitigate these risks. There is no doubt that we are living in an accelerated cycle of technological progress and repercussions. However, the intelligence, speed and agility of AI—and particularly machine learning (ML)—may be just what we need to roll with the punches.

As the speed of development outpaces our ability to mitigate potential risks posed by the systems we build, we are set on a path to accruing massive technical debt—the ever-increasing costs associated with modernizing code later rather than sooner. Too often, organizations in the private and public sectors are reluctant to pay off this debt, choosing an “if it ain’t broke, don’t fix it” mentality toward software maintenance and security. The problem is that as technology outgrows and outpaces our critical infrastructure systems, the potential for catastrophe escalates.

Machine Learning: A Tool for the New “Space Race”

Automated testing has proven superior in regression testing, especially in visually recognizing potential issues at the pixel level. If, for example, an important element of your interface is missing from the screen after an update, a visual test script can identify that faster than a human can. AI (and in particular, machine learning) generates test plans that provide more comprehensive coverage of the system under test and more practical coverage.

Traditional testing methods usually begin with a broad and hypothetical analysis of user interactions. Test engineers begin by casting a wide net to cover the many possible user engagement scenarios they imagine. In contrast, AI-assisted systems learn from actual user interaction, building script libraries that focus on known points of weakness and vulnerability. It also does this at speed and scale. This technology is going to be essential to software test engineers as they inevitably find themselves unable to keep up with the abundance of code generated from LLMs using traditional testing methods.

Technical Debt is Inevitable but not Unsolvable

Every new iteration of software has the potential to introduce unforeseen problems ranging from glitchy bugs to catastrophic failures. The risks of releasing new software vary immensely between applications: It’s one thing if the latest release of your music streaming app crashes and quite another if the system that runs the regional power grid fails. One will result in unhappy customers; the other, the potential loss of life.

The most critical systems (e.g., financial, transportation, safety, medical) are more likely to get frozen in time. Once a stable iteration is released, companies are generally not keen to make changes unless absolutely necessary—beginning the cycle of technical debt accumulation that grows until that debt is paid off by modernizing the code.

Deciding when to pay off technical debt has always been a matter of weighing pros, cons, costs and benefits. But sometimes, such as in the case of an epic failure, that decision is forced. Both the risk of breaking the system and the cost of modernization compel developers to leave well enough alone. Meanwhile, the longer a system remains unchanged, the more isolated, outdated, and obsolete it becomes, setting the stage for failure.

By introducing generative AI technology to the development stack along with other tools for authoring, compiling and testing software, developers will soon find themselves driving in the fast lane. With the security of knowing that code can be produced rapidly and released safely, owners of aging legacy systems will be more likely to modernize software sooner, helping them to pay off technical debt more quickly. That, in turn, could lead to increasingly rapid software development and release cycles, more work for developers, and more innovation. Such a workflow could very well become the embodiment of accelerating change, taking us from an “if it ain’t broke, don’t fix it” mentality to one where we anticipate the need for new code and avoid future catastrophic failures, or for that matter, human extinction.

September 12, 2023
Low-Code and AI: Friends or Foes?

The lines are becoming blurred between low-code and new artificial intelligence (AI). Historically, low-code/no-code platforms have introduced software development automation through graphical user interfaces, enabling professional and citizen developers alike to quickly build workflows and generate applications. But the rise of large language models (LLMs) represents an existential threat to the status quo of low-code development.

So, are generative AI and low-code friends or foes? Since new generative AI can produce complex code in milliseconds given natural language prompts, the barrier to software development has never been lower. On the other hand, enterprises already have ingrained low-code practices and operations, which may stick around for a while. With that in mind, there are plenty of ways AI and low-code can coexist.

Below, we’ll consider if AI and low-code are diametrically opposed tools or complementary forces. We’ll see how AI and low-code are merging and consider the benefits of using them in tandem.

Unleashing the Power of AI

LLMs, like OpenAI’s GPT-3.5 and GPT-4, can deliver impressive software generation capabilities, such as creating code snippets and even complete programs given natural language prompts. Because of these remarkable capabilities, it makes sense that low-code platforms should be a bit wary of AI.

Artificial intelligence can actually deliver on some of the original promises of low-code, like software democratization, enhanced agility and filling the widening skills gap. “ChatGPT could allow users to make more significant changes to applications, potentially enabling organizations to achieve far more than with low-code and in half the time,” wrote Romy Hughes on devopsy.kinsta.cloud.

There are also plenty of ways LLMs could accelerate the DevOps side of the cloud-native equation. In addition to code generation, AI could help generate configuration manifests, run code tests and perform cybersecurity analysis. While AI can’t fully replace the nuance of human oversight, it can indeed automate more and more elements of the software development life cycle.

Congruence Between Low-Code and AI

Although it appears likely that AI will replace low-code, there are actually many opportunities for symbiosis between the two concepts. Rather than eradicate low-code platforms entirely, LLMs will likely become more embedded within them. We’ve already seen this occur as low-code providers like Mendix and OutSystems integrated ChatGPT connectors. Microsoft has also embedded ChatGPT into its Power Platform as well as integrated GPT-driven Copilots into various developer environments.

“Low-code and AI on their own are powerful tools to increase enterprise efficiency and productivity,” said Dinesh Varadharajan, the chief product officer at Kissflow. “But there is potential for the combination of both to unlock game-changing automation for almost every industry. The power comes from the congruence between low-code/no-code and AI.”

There is also the opportunity to train bespoke LLMs on the inner workings of specific software development platforms, which could generate fully-built templates upon natural language prompts. This would make the LLM more custom-built and relevant to the platform at hand and ease development fluidity. In addition to integrating existing LLMs, another potential synergy is that low-code solutions could help automate the training of new custom AI models.

Tips to Keep In Mind

As with any technology solution, the choices should be driven by concrete business outcomes. Start by defining the business objectives and let that determine the technological solutions to arrive at the outcomes you desire. In the context of low-code and AI, this might equate to deciding between which models to support.

Next, enterprises must avoid risk when using low-code platforms. And on the AI side of the coin, platforms will have to navigate the data privacy and legal complications of using public LLMs. Like any new technology, AI and low-code will require governance, said Varadharajan. “Organizations should step in to standardize the tools, processes and DevOps cycles. Only certain AI-powered tools should be approved for development where there are agreeable security, privacy and IP protection agreements in place.”

He also explained that a focus on change management would be paramount in reaping the benefits of both strategies. “I suspect that the greatest barrier to adoption and implementation will be change management,” he said. “Enterprise users are accustomed to certain ways of working and can be resistant to change, making them unlikely to embrace AI-powered low-code. Leaders should anticipate this and incorporate change management into their AI/low-code adoption strategy.”

Closing The Semantic Gap

Low-code came on the scene to help citizen developers create applications without requiring advanced technical experience. Yet, low-code still requires knowledge of the development platform as well as specific programming terminologies and formulas. But now, since generative AI behaves in response to natural language, it has the potential to instantly bypass this barrier.

“Generative AI closes this semantic gap,” said Varadharajan. “Generative AI serves as a translator, and users no longer have to understand exactly how the system works.”

As more AI pair programmers come onto the market, expectations are rising within all areas of software development, including low-code platforms, to integrate these advanced models. If leaders can navigate the technical change effectively, the outcomes will likely significantly increase agility and output.

“Ultimately, all developers will end up saving time delegating repetitive tasks to these AI-powered pair programmers,” said Varadharajan.

August 17, 2023
Considering Scriptless Automation: iOS App Dev in 2023

According to Statista, over 31,000 apps were released on Apple’s App Store in March 2023. As impressive as that is, it’s considerably smaller than the number of apps submitted to the Apple store during the same month.

And it’s probably less than the number of apps removed from the App Store.

Why?

According to Apple, most submissions fail because of common issues like bugs, crashes, incompleteness, placeholder data and broken links.

But getting app approval is just one of many challenges faced by iOS developers today.

Contemporary iOS App User Expectations

The truth is, even if you slip by Apple, there’s an even greater critic to be concerned about: Your audience. Users are much less forgiving and have high expectations. If your app isn’t perfect, you’ll lose your chance at meaningful adoption and your users will just go elsewhere.

For iOS users, perfect is simply the status quo, and users have grown to expect it. In practice, this means that apps must be stable across devices and versions, see regular improvements. and provide a great user experience at all times.

Seamless experience between devices, versions and iterations
iOS users expect the same experience across multiple devices. From one iPhone to the next, from version to version and from screen size to screen size. It’s the responsibility of developers to prioritize a consistent experience across devices.

Fast release cycles and regular updates
Contemporary app users demand feature-rich applications that go above and beyond the simple functions they expect from an app. Given the statistics above, chances are that the competition is fierce. Achieving success usually requires an efficient and speedy release cycle with more planning, more deployments and more testing.

Easy and frictionless user experience
User experience (UX) and functionality are one of the big reasons iOS adoption is so strong. People have come to expect high quality from anything under the Apple banner: Users expect an intuitive and trouble-free user experience on every app with which they interact. Every user’s experience needs to be intuitive, issue free and consistent with other iOS applications.

Challenges Abound

Meeting those escalating user expectations comes with a wide variety of challenges. For example:

Device landscape fragmentation
With so many device types and form factors in circulation, how do you test across all of them? With dozens of iterations of the iPhone combined with an array of versions, screen sizes and configurations, app developers need a way to test on enough devices to cover the majority of their user bases.

This leads many developers to turn to simulators and emulators to cover devices they lack access to.

This poses another problem. Simulators aren’t perfect. A simulator doesn’t replicate the functions of the actual device; it can only mimic certain aspects of an iOS device. And it simply can’t effectively mimic hardware, component functionality or network.

Using a simulator, you can’t test how an application will respond to factors like low battery, a rising network spike, or limited memory, not to mention GPS and camera functionality. You also can’t monitor usage metrics or run meaningful performance tests.

Real devices present their own challenge. The vast majority of the time, developers will have to worry about the cost of acquiring, storing, maintaining and updating devices. In addition, they’ll have to centralize and control access to them. In an increasingly remote workforce, it’s not a great strategy.

Manual tests
Today, most organizations are over-reliant on manual testing. The result? Running test cases becomes the bottleneck that holds up releases. Sure, manual testing is unavoidable in some cases, but their ad-hoc, inconsistent nature leaves room for error. No matter how detailed the instructions may be, people test differently, and that’s a disaster waiting to happen in today’s complex software world.

Maintaining complex test scripts
If you’re automating test cases, you’ve experienced the pain of maintaining code-based test scripts. Every release requires coinciding updates to countless unit tests, integration tests and UI tests. The smallest changes can break test cases, causing false negatives and more deployment delays.

On top of that, you’ve also got to worry about retaining talent that understands your language-specific testing framework. Given the economic uncertainties of today, that’s certainly not a good situation to be in.

Constant iOS updates
Each year sees Apple deliver iOS major releases and a variety of minor releases, patches and bug fixes. Organizations have to test after two release cycles: Their own and Apple’s. Failure to do so can lead to compatibility and App Store compliance issues.

App store guidelines
As I mentioned above, Apple maintains strict guidelines for any apps published on the App Store. Excellent testing can mean the difference between releasing an app or waiting another few weeks for the next approval. When time is money, this adds up fast.

Security at scale
As requirements change, scope increases and features add up, it’s easy to see how it can become more and more challenging to monitor for potential security flaws. In turn, testing needs to be continually updated to reflect the latest security risks.

A Shift Toward Scriptless Solutions

Scriptless automation is part of a growing industry of no-code automation tools, often dubbed the no-code revolution. It’s everything test automation is without the reliance on code-based frameworks.

Scriptless test automation involves recording user interactions with app elements, asserting expected outcomes and assessing the results. The test is then automated, templatized and extended to test other scenarios.

With scriptless test automation, you can walk through test cases step by step. Some tools even allow you to test on live devices and choose from real iOS devices that are hosted in the cloud.

Scriptless testing allows you to:

● Easily reuse and templatize test scripts. Scriptless automation makes it easier to reuse test cases, create templates and compose new test cases.

● Enable faster time to value. Write test cases quicker, make changes without knowing how to write code and integrate directly with your CI/CD tool. As soon as you make changes to your application, your testing team is right there. Some no-code testing tools can analyze your source code and identify testing gaps so that you can address them right away.

● Untangle the web of code-based dependencies. With scriptless iOS test automation, testers don’t have to lift and shift their code every time they make a big change. Instead, the no-code framework provides a visual, easily-navigated UI that tells you simply what’s passing, what’s failing and what needs to be updated.

● Improve collaboration between teams. Scriptless iOS test automation improves collaboration between testers and developers by making it easy for all teams to visualize test cases.

Real Device Testing

When the pain points of fragmentation meet the shortcomings of simulation, developers are wise to test on real devices. At the end of the day, live device testing is the only way to accurately capture an end user’s experience.

Yet it’s no secret that managing your own device lab is expensive and unrealistic for modern remote work environments. A real device cloud setup solves this problem: A device cloud hosts devices for you that you can access from your desktop, from anywhere.

Given the ever-increasing complications of today’s mobile app landscape and the incredibly cut-throat mobile app landscape, it’s worth keeping in mind that you may only get one chance at making the right impression on your audience. Getting testing right is the key.

Into the Future

Everyone expects more. As a competitive organization, you have to do more with less: Fewer resources, less time and less room for error. Scriptless automation and real device testing won’t guarantee that your app stands out from the crowd, but it will certainly help.

July 31, 2023
Majority of Organizations Report Benefits From Low-Code Platforms

Some IT departments are feeling the strain amid recent economic downturns. 2023 has already seen a disproportionately high degree of layoffs in the tech sector. As a result, there aren’t always enough software developers available to meet the demand. This has led some organizations to turn to new ways to upkeep morale and reduce burnout, retain productivity and do more with less.

Low-code development is one solution that could help tackle rising application backlogs. Low-code/no-code platforms use reusable components to help engineers (and citizen developers) construct functional applications and internal workflows. Many teams report they are using low-code to rapidly deliver new features. A recent study from Microsoft found that 89% of CIOs and IT pros said low-code is effective in increasing efficiency.

Microsoft Power Platform recently sponsored a study that surveyed 2,000 IT CIOs and IT professionals on their use of low-code platforms. According to the report, users benefitted from these platforms by modernizing legacy IT, improving efficiency and reducing costs, among other areas. Below, I’ll review some key takeaways from the Microsoft study and compare them with other perspectives.

The Benefits of Low-Code Development

The report showcased a slew of benefits from the use of low-code platforms. One is modernizing legacy applications—87% of CIOs and IT pros said low-code is very useful in helping their organizations modernize legacy applications. Solving the technical debt issue is top-of-mind, since 69% of IT leaders identified technical debt as a threat to innovation. Another key benefit is efficiency. The study found that developer efficiency with these platforms significantly increases over time, averaging 62% over three years.

Low-code platforms are also a prime area to insert artificial intelligence and more automation into the software development process. Microsoft, which recently announced it was integrating ChatGPT into its Power Platform, reported that 87% of CIOs and IT pros said increased AI and automation embedded into low-code platforms would help them better use the full set of capabilities.

Finally, a significant benefit is cost reduction. A full 87% of those surveyed said low-code is effective in helping reduce costs. These solutions could accelerate the completion of the software backlog, increasing efficiency and lowering the resources required to deliver. This comes at a time when cost optimization is critical to avoid rising cloud fees.

How Are Companies Working With Low-Code?

So, how are development teams actually working with these platforms? One common use case is improving data processes by streamlining integrations and having a centralized repository. In fact, 86% of CIOs and IT pros said low-code helped their organizations generate more accurate insights from their data. These data-driven insights have been used to help better serve customers and internal stakeholders.

For example, ÖBB, an Austrian rail operator, leveraged a low-code platform to synchronize data and automate customer service inquiries with virtual agents. Other case studies report using Microsoft Power Platform for migration from legacy systems and reduced document processing lead time.

Looking outside of the Microsoft report, however, not everyone is fully on board the low-code bandwagon. For example, the CEO of StackOverflow has expressed reservations because low-code platforms ultimately have a ceiling. With low-code, there’s a limit on customization, making it a less-than-ideal fit for experienced developers or technology-specific companies. Organizations must also mitigate the potential security repercussions of allowing business users to create applications, requiring new governance and policies. Low-code platform users may also fall victim to vendor lock-in and uneasy data retrieval—underscoring the need for open platforms with programmatic access.

The Advantages of Low-Code Platforms

Low-code solutions are a viable option to help clear items from the IT backlog, automate tedious processes and free up engineers to focus on more pressing matters. Some low-code/no-code tools also help democratize application development to those with different skill sets, thus bringing in new users to the development arena. And interest in low-code continues to pick up—Markets and Markets forecast a compound annual growth rate (CAGR) in the low-code development industry platform market of 28.1% to reach $45.5 billion by 2025.

Naturally, the findings and case studies in this particular report are a bit skewed toward the benefits of using the Microsoft Power Platform. Nonetheless, it serves as an indication of the various advantages of low-code platforms. For more insights, you can read the full report here on the Microsoft Power Platform blog.

April 28, 2023
Can ChatGPT Fix Bugs? ‘Wolverine’ Dev Says YES

Welcome to The Long View—where we peruse the news of the week and strip it to the essentials. Let’s work out what really matters.

This week: Instead of AI aids for programming, what about for debugging? The pseudonymous “BioBootloader” says he’s persuaded GPT-4 to make his code self heal. (more…)

April 13, 2023