The Appian Max Approach to Low-Code Success

The business world is changing. In the face of constant challenges from supply lines to staffing, the most successful companies are the ones who can evolve the fastest. Enabling that evolution is a dizzying array of technology and software that often takes years to develop and deploy. Modern companies that demand speed simply cannot afford to wait for custom high-code custom solutions that met business requirements from one or two years earlier.

Low-code development and automation is the answer, and at Appian we know a thing or two about doing it well.


This page serves as your welcome wagon to low-code automation. We're going to talk a bit about what low-code is as well as what you will find throughout all of the other articles in the Appian Success Center. Whether you're a new customer of Appian or just exploring the low-code space, our goal is simply to help you start on the right path to success. Throughout all of this, we're interweaving our philosophy that success covers five primary domains:

  • Vision - Identifying the highest value automation opportunities and connecting them to measurable outcomes
  • People - Forging small, agile, low-code teams of individuals with a combination of technical and business skills
  • Delivery - Fostering a mindset of continuous incremental deployment of value
  • Architecture - Tailoring the right automation approach to the goal, because not everything is a hammer-and-nail situation
  • Platform - Creating synergy between multiple applications to accelerate business transformation

Defining low-code

Depending on who you ask, low-code has many definitions. Gartner, for example, defines a low-code application platform as, “an application platform that supports rapid application development, one-step deployment, execution and management using declarative, high-level programming abstractions, such as model-driven and metadata-based programming languages.” While definitions like this are interesting, there's often a lot of confusion about what it actually means to a business.

At its core, low-code development abstracts away much of the nitty-gritty high-code development requirements. Appian provides best-of-breed integrated development tools, already vetted for functionality and security best practices, so that even the most junior developer on the team can immediately start creating applications.

Rather than a developer using Java, HTML, CSS, PHP, SQL, and more all within the same project, each team member only needs to know how to use Appian- and that lets developers focus on the fun part: solving business problems.

To summarize, low-code provides two distinct advantages to developers:

  • Speed - Low-code allows developers to work rapidly by selecting from a library of ready-made tools or taking it a step further by forging their own reusable tools
  • Ease of use - Low-code removes the barrier to entry to software development– since the most challenging software pitfalls are handled by Appian, the developer can focus on what really matters

Developer story: A light bulb moment

Many new Appian employees participate in an intensive two-week training program known as Employee Academy. Each class is often a mix of industry veterans as well as fresh college graduates.

The class culminates in a five-day project simulation where each student must take what they’ve learned and produce an application meeting business requirements provided to them. At the end of class, they must present their work to peers and managers alike.

We offer the same training externally to anyone who wishes to learn, as well.

One student, a newly-hired manager who had 20+ years of software experience in high-code development, produced an exemplary application in just five days. When asked how long it would have taken him to do it using high-code, he thought about it for a moment and said, “The first 80% could have been done in about five days if I worked nights and weekends. The last 20% would have taken two or three more months.”

The instructor then gestured to the class and said, “You’ve got more than 20 years of experience, and many of your peers here have none- yet produced 90% of what you were able to do today. What do you think the possibilities are if someone like you was leading a team of four or five of them?”

The manager’s eyes went wide as he realized just how much of an accelerator low-code actually is. With only five days of instruction and no professional experience, his young classmates were able to nearly match his output on their own.

That’s the power of low-code.

Appian Max

Appian Max is our low-code philosophy and methodology. We’ve created over time from helping hundreds of businesses transform their operations and shift their mindset to thinking like a software company. As you explore the other articles within Appian Max, keep in mind that these principles apply to any business looking for low-code transformation– not just Appian customers.

To better help you reach your own lightbulb moment, we suggest starting with the top five domains of Appian max: Vision, People, Delivery, Architecture, and Platform.


Low-code is a different approach to software development, and it might feel a little strange especially to organizations who aren’t familiar with software development to begin with. For best chance of success, organizations need to think beyond the constraints they traditionally experience through high-code software development and focus on what matters.

It all starts with establishing a vision. That vision statement means a commitment to solving big business problems with rapid and iterative low-code development, not restricting low-code only to peripheral applications. While low-code will certainly solve those small problems, you are not likely to see the synergistic power of low-code until you tackle the big challenges.

Establishing a vision also requires goals and metrics. Importantly, your goals must be defined in terms of the value they deliver for the business. We like to define this by using the outcome rather than the method.

For example, a weak goal might sound like, “We need a better way for customer service representatives to process tickets.” This doesn’t offer much beyond “we need a thing.”

A better goal would be, “We need to enable customer service representatives to quickly process tickets by providing them complete customer context and intuitive action choices.”

This second goal already starts describing the features your solution requires with phrases like “complete customer context” and “provide intuitive actions.”

From there, the next step is creating measurable metrics of success. In our example, this might be an 80% reduction in ticket processing time, or a 50% increase in customer satisfaction. This is where you define the value to be delivered.


Low-code enables your team to work quickly and efficiently, which also means you don’t need as many people as you might have thought. The most effective low-code teams are a mixture of technical and business expertise, and might not come from traditional software development backgrounds.

Throughout all of our successes, we’ve seen a few truths about low-code teams hold strong.

Smaller, independent teams move faster

Appian organizes teams in groups of three or four developers paired with a business expert. Each team member is a generalist rather than a specialist, and that enables them to work interchangeably on different aspects of an application. They can also switch gears as needed, switching between developer, business analyst, tester, and more.

As an organization grows its low-code practice, it means adding more of these small teams rather than hiring larger pools of developers. These teams may work independently, or join together under a common framework that later provides powerful low-code synergy.

Emphasize teamwork, not specialists

Since there is no need for backend database developers, front-end UX designers, integrators, or other high-code specialists, low-code developers can focus on mastering a single toolset and solving problems.

That’s not to say that some developers won’t dive deeper into certain skill sets. Appian encourages that within our teams, and we call it the “developer and _____” framework. Some developers will also become highly knowledgeable about certain industries, business practices, or certain aspects of low-code automation. The goal for these individuals is not that they become the “specialist” of the team in that topic, but that they further empower the team by sharing that knowledge and offering insight.

Recruiting for aptitude

The background of low-code developers don’t always look like traditional developers. Many of the most successful low-code developers don’t have computer science or engineering degrees (though it certainly doesn’t hurt), but they do have a passion for technology and learning.

The profile for a successful low-code developer might be easier to find than you think.


While low-code development is fast, it’s the methodology supporting it that produces quality results that provide value. Appian Max is rooted in agile development with our own twist. We break down each project into four phases:

  • Initiate - “What do we build?”
  • Build - “Create the value”
  • Release - “Test it and deploy it”
  • Optimize - “How are the metrics? Can we improve them?”

The most important thing to remember about a low-code delivery is that it’s supposed to be fast and iterative. The ultimate value of software comes from solving problems, not how many features it has. The goal is to deliver the most important value up front, tying back to the original vision and goals, then quickly and incrementally improve on the software until there enough value exists that other projects become a bigger priority.

Supporting this four-phase approach is a lot of internal processes, quality checks, and communication.


Not every problem in a workshop requires a hammer. Sometimes you need a screwdriver, drill press, mill, sander, or just a pencil.

It’s easy to focus on using only one type of automation technique to solve every problem. We often see this with something like Robotic Process Automation (RPA), where everything looks like a “bot problem.” With Appian, and low-code in general, consider that there is an entire suite of world-class automation tools available to solve problems.

Match the technology to the problem

Since low-code developers are generalists who understand the complete capabilities of the platform, they aren’t thinking only in terms of using the piece of technology they specialize in. Appian developers, in particular, understand the importance of focusing on the business problem and its context. This allows them to select the right tool for the job and use it effectively.

A 360-degree view of data

Since knowing the context of a business problem is important, developers and users need to see the data supporting the problem. In many businesses, this data exists in silos throughout the organization that don’t talk to one another. That usually leads to duplication of data and messy problems.

Appian solves this through using connectors, where low-code developers are able to access that data where it is and use it to solve business problems. More importantly to users, they no longer have to know where to find what piece of information, as it will all be available to them in a single place.

Utilizing intelligence

The goal of automation is not replacing workers, but supporting them and empowering them to do more. Considering the customer service example from earlier, we’re not looking to remove the customer service department, but to better help every representative quickly solve problems by giving them the information they need, when they need it, and offering them intuitive ways to trigger additional workflows to help solve those problems- and they can do it all from one place.

Sometimes that workflow is simple, with a series of beautiful interfaces and exchange of data to a particular place. Other times it might require accessing data through integrations with outside systems. In more advanced cases, it might involve software robots and artificial intelligence.

Low-code developers are able to choose the right tool for the job and deliver the value.


A common pitfall for many organizations is thinking about each low-code application in a vacuum. Over time, and more applications, this leads to a project-centric mindset that lacks consistency and a broader strategy.

A better way to approach your low-code platform is thinking in terms of reusability. Consider how aspects of one application could feed and support another application. Planning for this reusability at the beginning accelerates development later on. Since there are fewer things to create with every new application, developers focus only on solving the new problem and not re-creating what’s already been done.

Taking it a step further, using a coherent low-code platform strategy opens up additional possibilities for discovering opportunities. Process mining, for example, can leverage data produced by your low-code platform to visualize your inefficiencies and identify opportunities to improve your processes. This works better when your processes interconnect with one another and provide a complete picture of your organization’s practices.

Getting started

Now that you have the basics down, it’s time to branch off further into Appian Max. If you’re new to low-code, you should start with identifying low-code opportunities and establishing a vision.

As you explore, remember than soon over 70% of new enterprise applications will use low-code or no-code technology. As it becomes more widespread, the importance of establishing a solid strategy around its use will become ever more apparent. The decisions you make today will determine how successful your organization makes the jump to low-code– and we’re here to help.