How to Upgrade Your Low-Code Strategy for 2022

Share this article...

The beginning of the year is always a time for reflection. It is easy to assume the processes you have in place are the best options available, but ‘low code’ challenges teams to keep seeking greater agility. After all, low-code applications are all about agility, accessibility, and ease of use.

But low code doesn’t magically remove every silo and bottleneck that restricts your team’s ability to use the tools they need efficiently. So, as we progress into 2022, it’s worth taking stock of how the low-code environment has changed, and how we can better achieve a low-code reality this year than ever before.

Low Code is Not Just for Production

What a true low-code vision does is allow your entire team, from a developer to a business user, to utilize ‘clicks, not code’ to do what they need to do inside their business applications. But looking at this production level as the only place where low code is essential is missing a huge part of your organization. What good are low-code apps if they cannot be developed using low code? How helpful is it that I can use Salesforce CPQ with clicks as an end user, but once I need to update a pricing rule I am stuck waiting for the next sprint to be released?

And quite frankly, we are at a point where most of Salesforce can be maintained in this low code way. End users see how Salesforce makes it easy to build a new field, update a picklist, or even add a new service territory. What they don’t always understand is why they can’t just make the change in production on their own. 

Low-code solutions are incredible for business agility, but they are not error-proof, which is why testing changes and customizations before releasing them to production is so critical. The accuracy of Salesforce data is essential to reporting critical data about your daily operations and projections, as well as helping team members to make key strategic decisions quickly. 

Similarly, users must be able to rely on processes in Salesforce to complete their work and generate transactional data. A missing column, bad relationships, or some other misconfiguration could result in a quarterly meeting coming to a screeching halt, or your users not being able to market, sell, and service your customers.

Accelerate Low-Code Innovation

Any true low-code vision should include a plan to engage business users, admins, and devs in application lifecycle management (ALM). Rather than siloing changes to a small team working out of one sandbox, shift the mindset to “anyone should be able to make changes within our set framework.” This will not only improve collaboration, but also enable the business to work faster and more efficiently.

The key to empowering business users to make their own changes (without total chaos), is making it easy and fast for them to work in a safe way. This starts with giving them their own environment to play around in without the risk that they accidentally screw up what the rest of the team is building! You will also need to help them keep their environments in sync with the constantly changing configurations in production – and yes, this should be able to be done completely with clicks.

Utilize master sets of metadata and configurations that end users cannot change, but allow them to copy data into their own sandboxes to make the changes they need. Once they are happy with the change, pair them with an admin or developer who can review the work to make sure it’s technically sound. Only then should their change be merged into a shared QA environment to make its way up the release train to production. This strikes a healthy balance between self-service and the integrity of your source of truth.

Another way to improve collaboration – and thus accelerate innovation – is to increase communication. Sandbox and Staging are not just for the people making changes to Salesforce. Consider creating a focus group of power users from each department and give them early access to your latest updates and reports. Letting them play around and test out new functionality will help discover and fix issues earlier in the development cycle, so that it’s actually usable by users when it hits production. Take communication a step further by scheduling a ‘lunch and learn’ or recurring meeting to walk users through the latest changes.

What If Things Go Wrong?

You’ve probably heard this a million times already, but it gets truer every day. It’s no longer about if something will go wrong, but when. The rollout of a new solution or a major update can be exciting. It can also be the source of incredible pain should anything go wrong. That’s why the other important side of this mindset shift is to plan for the worst-case scenario. 

The old mindset says “restrict access to protect the system,” which slows down the pace at which the business can innovate. Conversely, the low-code mindset says “we want to accelerate innovation by enabling as many people as possible, and when mistakes happen we are prepared for them.” This can be scary, but remember it’s about prioritizing driving more value for the business while mitigating risk by having a tried-and-true process, as well as a solid recovery plan.

Oftentimes people understand the need to back up production data and applications, but forget that data protection is a critical part of the development and deployment process as well. A bad deployment or a bad script can sometimes corrupt or result in the unintended deletion of data like Salesforce records. The speed at which you identify these issues can be crucial in mitigating the fallout of a bad rollout.

Configurable alerts and alarms can monitor for unusual activity or deltas, which could be caused by malware or bad code run amok. The last and most important step to accelerating response time is to confidently understand what has changed in your environment and where your fixes and rollbacks need to be targeted. 

Do I Have the Best Process in Place?

Ask yourself if you can:

  • Compare environments on demand within a few minutes?
  • Move data and metadata between environments in a way that your Salesforce Devs, Admins, and Business Users can all use?
  • Proactively be alerted when something out of the ordinary happens?
  • Quickly recover from a data loss without bringing production operations down?
  • Train your low-code users on this process quickly, within a week perhaps?

Common Pitfalls in a Low-Code Strategy

There is no single solution for every business problem. Customizations are necessary and the strongest platforms in the market today are the ones with the most effective integrations, open APIs, and safe environments for testing (i.e. Salesforce sandboxes).

Trends in the industry show us that this is going to be the standard across industries for years to come. In addition to existing marketplaces for solutions like the Salesforce AppExchange, enterprise players like Microsoft’s PowerApps or startups like Clappia are going to help bridge the gap between cloud data/applications and those one-of-a-kind demands every business encounters.

If they aren’t already, low-code solutions are an inevitable part of your organization’s future, and in order to be successful, there are a few common pitfalls you want to avoid:

Pitfall 1: Low Code ≠ No Code

Low-code solutions will not replace your engineering department. They will not replace SaaS. Low-code solutions are meant to bridge the gap between complex systems and business needs.

While this doesn’t replace your engineering department, it should change how they work and build solutions. Information should be stored in databases with structures matching, or at least queryable with corporate taxonomy. Solutions need to be built with the understanding that users might build their own customizations, provide access to external users, or significantly increase the load on a back-end.

Low-code solutions will also require maintenance and go through a lifecycle like traditional applications. There are many ways to achieve the same goal in Salesforce, but that doesn’t mean they’re all equal. Best practice is to adopt a ‘try clicks first’ approach to building solutions and choosing partner applications. This will provide greater flexibility, make maintenance easier, and reduce future technical debt. When programmatic code is the only option, make sure to document it well. 

Pitfall 2: Low Code ≠ Self Service for All

Low-code solutions are marketed in a way that screams, “Anyone can do this!” But in reality, these solutions are not a free-for-all. They still require a governance strategy to ensure the solution functions for the business. With these basics in place, engineering can be comfortable with expanding access to application development:

  • Understand the business requirements and objectives for the low-code system.
  • Understand the process end-to-end or at least understand the necessary inputs/outputs of the app.
  • Understand the underlying data supporting the app.
  • Understand how changes are introduced to the system, including what testing steps are required and how changes will be rolled back if needed.
  • Be able to communicate any challenges and requirements to a technical escalation point.
  • Ideal/Optional: Have prior training or experience in development. Attend internal or third-party training prior to developing low-code solutions internally.

Low-code solutions are not meant to create a magical self-service experience for all of your users; some capabilities, especially when simplified, should not be put in the hands of users. Standard processes should still be followed for things like permissions management.

It is recommended that an organization formally rolls out their first low-code solution in conjunction with a formal engineering team. This is before creating an internal team within another department like marketing or sales engineering.

Pitfall 3: Just Because You Can Click…

Many low-code solutions will allow you to create applications that surface sensitive internal data or allow users to quickly execute tasks with elevated or impersonated privileges. Just like with Salesforce permissions and profiles, you want to control where and who is building these solutions, and most importantly, who will be using them. 

Ensure the sensitivity of the data matches the level of access a user should have. This is especially important if the app allows any kind of download or export of data. Ideally, data should never need to be exported during the development cycle. Any data that is required for development should be moved securely between environments and tracked in an audit trail.  

How Do I Start?

A true low-code reality is a state of mind, not any given solution or tool. Your systems should work together to support ease of use for your end users and efficiency for your dev and admin teams. There are however some solutions that do give you a leg up when trying to achieve low-code development.

A common theme throughout a true low-code reality is the ability for anyone on the team to configure and test their changes, which requires dedicated environments for individual work and transferring data and metadata between environments. Prodly AppOps, next-gen DevOps for Salesforce, was designed with the end user in mind. But it also works via Salesforce DX, so everyone on the team can participate in the release process whether they prefer point-and-click or the command line.  

Proactively monitoring for potential issues and quickly understanding what changed is also important. Tools like Spanning don’t just protect your critical records, but also your metadata, workflow, profiles, and more. Spanning allows you to quickly compare, down to the line level in your code, and restore custom metadata or export it for review by your Salesforce development team.

No matter what tools you partner with, you should make sure that they are partners that actively help your team maintain low code as a best practice. 

Final Thoughts

Whether a low-code reality is far off in the distance, or you already have a state-of-the-art process in place, 2022 is the year to upgrade your low-code development process. Take stock of what you can do to empower your admins and business users to make the improvement they need, when they need it. Here’s to low-code success in 2022! 

Add Comment