Developers: Empower Your Admins and Make Your Team More Efficient


I was in a sprint planning meeting a while back where we were looking at the work we wanted to accomplish over the next two weeks. We were a smaller team with 5 admins and 3 developers in a customized org with a good amount of apex. Once we scoped our tickets, it was clear that the majority of them required a developer and we didn’t have the capacity. Even more, since most of the work was falling to the developers, it left our admins under utilized – a big no-no.

Utilization: Getting The Most Out Of A Development Team

So what happened in the scenario above? Well, we had to push a bunch of the developer tickets out of the sprint because we weren’t going to get to them. Then, we had to bring in additional tickets for our admins. And that means that we’re 1) pushing out the timeline on important work that we had originally prioritized and 2) now working on things that are of lower priority just to make sure people have things to do.

In a word, we were inefficient. We weren’t nimble. We were clunky and slow. And we decided to do something about it.

How Developers Can Help Support Admins and Business Partners

As a developer, one of the things I’m constantly thinking about as I write code is “How can I avoid having to touch this code again?” Now, that’s not always possible, but the idea is that I want to right code that we don’t need to spend time revisiting in the future, even if the business strategy shifts slightly.

I’m going to give you two concrete examples of things you can do to start empowering your admins and become less of a blocker as a developer, but before I do, it’s important to call out that a big part of this relies on you having a solid understanding of your relevant business processes, goals, and how your end users will interact with whatever you are building. You need to be able to identify what levers the business will want to pull in the future, and then separate those things from the application logic. Let’s get into some examples of how this plays out in real life scenarios.

Custom Settings and Custom Metadata

Your boss slacks you and says that they want to do an A / B test on a particular page used in your community. They want you to create two different versions of the page (Version A and Version B), and at the start, they’d like to show Version A to 10% of users, and Version B to 90% of users. Depending on the results of that test, they may ramp up Version A or decide to abandon it entirely.

So how would we handle this? I’ll avoid the details of the page itself as that’s irrelevant, but let’s assume we call an apex method that returns which version of the page we should show. It might look something like this:

Ok, that works, easy enough. You ship the code and move on. Two days later your boss comes back and says “Version A is on fire! Let’s ramp it up to 50% of users!” So, you pull up VSCode again, make a tweak and send it up:

What happens when they want 95%? What happens when version B should be at 0%? This is a great example of a lever that the business can pull, so let’s find a way to make it easier to pull.

Ok, so whats changed? Well, first, I’ve created a new custom setting thats storing an opt in percentage in the OptInPercent__c field. In a real life scenario, we’d want to make sure that the values stored in this field match what we’re expecting to receive, but for now, lets just assume that we are always setting that value to be between 0 and 10.

The benefit of using a custom setting like this is that any Admin on my team (or anyone we give access to) now has the ability to change this percentage on the fly by simply updating a custom setting. Doing so immediately impacts the end user’s experience, but. doesn’t require me as a developer to do anything. Win win!

Invocable Methods

One of my favorite ways to empower admins is via invocable methods. Invocable methods are methods that can be invoked from things like Flow. Lets walk through an example.

Lets say one of the admins on your team is working on building a flow on Opportunities. While Flow is constantly improving, there are certain scenarios that are simply put, better handled in Apex (Map handling is one example where things can be simplified drastically in Apex). Invocable methods allow you to combine Flow and Apex – best of both worlds! Here’s what an invocable method might looks like:

So here we’ve written a method that is now accessible within Flow. Your admin can simply call this as an Apex Action and pass in the list of Opportunities they are working with. You can then make your updates in Apex, and then hand the Opportunities back to them to finish the rest of the flow.

Invocable methods are really fantastic ways to give your admins some control to handle complex scenarios while still doing the heavy lifting via Apex.

Hope these two examples helped illustrate how you can help streamline your admin and developer processes!


Please enter your comment!
Please enter your name here

This site uses Akismet to reduce spam. Learn how your comment data is processed.