BACKGROUND IMAGE: verticalarray/stock.adobe.com
As enterprises' need for software grows, so does the need for programming, yet new programmers show up at a much slower rate. To address this imbalance, short-staffed dev teams can rely on a set of tools designed to abstract programming. The low-code approach reduces or eliminates traditional programming in favor of a higher-level model, where staff can manipulate recognizable functions as a whole rather than line by line.
High-level development means the organization relies heavily on the low-code tool to get things right, so the product must be the right fit for its users and for the application project.
In this faceoff of low-code tools, we compare two prominent players in the market: Microsoft PowerApps and Appian. While one has the look and feel -- and power -- of familiar Microsoft tools, the other successfully bridges the gap between IT professionals and users in other departments. Let's examine the particulars in this PowerApps vs. Appian clash.
Carefully determine a model for application component creation if you adopt low-code tools. The tool must displace a lot more work than it creates. It should have the power and scope to handle a cohesive sequence of functions, so the output is similar to a black box of features that integrate at a single point. If a low-code tool generates a lot of independent components, then it must integrate them without falling back to manual coding. Integration work has the potential to overwhelm the benefits of low-code tools.
Low-code tools aim to ease application customization, or else you can waste more time than you save using them. In reality, organizations likely won't abstract all code for a practical range of development projects, because customization is never fully banished.
Low-code tool vendors also strive to integrate their products with an organization's traditionally developed application components so that new functionality and features fit within the rest of the business workflow -- and different vendors' products go into different aspects of a workflow. Low-code products on the market vary in the extent to which they are designed for typical workflows and application divisions. Development practices tend to separate apps into the front and back end. Front-end processes focus on support for various user devices and provide the information processing needed to create business transactions from user inputs. The back end processes business transactions, relying on infrastructure from the data center, in contrast to increasingly cloud-focused front ends. Low-code tools are generally most useful on the front end, where changes occur with more frequency than they do on the back end and the range of functionality is limited.
Against this backdrop, development teams have choices, exemplified by Microsoft PowerApps and Appian. PowerApps has a longer track record, but newcomer Appian might come closer to a true no-code development experience.
Microsoft PowerApps aims to be at the center of the development process and is designed to be extended and integrated. PowerApps has excellent support for GUI design, supplemented by abundant templates, not to mention the ability to integrate with many popular web or programming languages and lots of flexibility for customization. A user can build apps for Android, iOS and Windows 10 OSes and with web servers or pages. PowerApps integrates with Office 365, as well as with Dynamics 365, Microsoft's ERP and customer relationship management framework. Microsoft packages PowerApps alongside PowerBI for business analytics support and Microsoft Flow for workflow automation.
PowerApps' flexibility and integration comes at a price. It can be a handful for the typical web designer. If you push its capabilities to the limit, you can run into the problem noted above: The integration work threatens the value of a low-code concept.
In the other corner, Appian takes a PaaS approach, which focuses more on the front-end process. Appian handles integration via business process management (BPM) and Business Process Modeling Notation (BPMN).
The Appian low-code model looks a bit like a light version of PowerApps, and it presents features in a way that reduces complexity and elevates functionality. Appian nearly achieves the mostly mythical promise of no code for application front ends. Appian users really can drag and drop components into a workflow for basic development tasks, and it's easy for those who lack programming skills to perform limited customization. With Appian, users can build apps for Windows, Linux, iOS and Android, and it integrates with application servers, databases and cloud IaaS providers.
Appian's package suits basic app and front-end design, and it enables users to organize components from other languages and sources, provided they understand the BPMN syntax. However, if you want to step outside Appian's basic target area and do more customization, you need coding skills -- more than PowerApps demands. If you want to offload basic development activity to power users within the business, Appian can be helpful, but development teams could find it frustrating.
When you choose between PowerApps vs. Appian, the workflow -- or sequence of tasks to complete when a transaction or event occurs -- makes a big difference. Low code intends to simplify that workflow.
Appian has one of the best records of application development acceleration and modernization of any low-code tool. For example, some customers report development time decreased by as much as 12x.
Appian's focus on the front end, where data is formatted more so than processed, means users should follow some best practices to achieve similar results. Create a data model that flows across the boundary between the front and back end to populate data for users, and then refill the model with changed information. With this type of BPM model, Appian adheres to a definition of how specific user steps align with tasks on the back end. Processes and application components then fit into this data model framework.
Appian offers two options to assemble application components. With its quick view, users combine functional pieces through a GUI, while its more sophisticated designer view calls on a JSON-based language to help the user build pieces from more detailed elements. In most organizations, IT professionals familiar with JSON should use designer to create the functional pieces that business-minded workers assemble and customize into appropriate workflows in quick view. The GUI offers a good compromise for pure business users and IT types alike, but it might not go far enough to simplify Appian's many features. And some users would prefer a more visual orientation.
On the other hand, PowerApps echoes the look and feel of other Microsoft products, such as Office programs. If you use PowerApps as an adjunct to Microsoft software, the integration of information between the front and back ends is fairly seamless. PowerApps caters more to Office users than generally to developers, although the dev crew -- particularly those with Windows Server or Azure chops -- should find the tool's customization and integration capabilities appealing. For Office users, the PowerApps GUI is easy to understand, and many adopters particularly like the similar feel to PowerPoint, where they assemble screens from objects. However, users without Office experience might find PowerApps' interface less intuitive than Appian's and could struggle to create data models. It's best to start with data models, but the design of the application GUI could encourage users to leave data models until after the GUI designs, hindering app development.
For the majority of users, Microsoft PowerApps is the preferred choice for a low-code development product. Its Office-centric GUI and sheer power and flexibility put it over the top.
Appian's visual interface is helpful but unfamiliar compared to PowerApps. Most enterprise workers know and use some Office tools, so the continuity is comforting.
On the developer-centric side, PowerApps can integrate with virtually any back-end cloud or data center architecture, with tools that a development team will easily understand. As it is a Microsoft product, expect PowerApps to work most easily with Microsoft-hosted apps.
Both Appian and PowerApps can satisfy a low- or no-code requirement, yet both illustrate that code in some form is inevitable. After all, in the real world, software is based on programming. And it's therefore critical that tools in this market never inhibit how components integrate into a working application.
Compare two more low-code options: Mendix and OutSystems