Accelerators: The Fastest Way to “Accelerate” Your Digital Delivery

In the previous article, we explored high-level principles that support accelerated digital delivery—Trust, Clarity, Visibility, and Consistency.

These are all well and good, but for principles to mean anything, they have to make a practical positive difference where the work is done.  (We all know companies that preach one thing but do another, just as we know “principles” that buckle and fail under the pressure of reality.)

So how do we bring a principle—say consistency—to bear on actual work?

I’m glad you asked. 

In this article, I want to zoom way in and show you how we embody the principle of consistency in our development processes.

The method is what we call “Accelerators”... but before we get into those, let’s touch on a problem I see in a lot of development teams (and myself).

Why shiny things can kill your business (my precious)

Humans are wired to pay attention to anything new, but I often feel that developers got a double dose of the shiny distraction gene.

Developers LOVE a new shiny thing—especially if it’s a tool or process.

But this is a big reason why we (and our digital development projects) are so often derailed.

I’ve seen this too many times to count in my career. A development team makes a rational and sensible decision to try something new. The new thing—whatever it is—promises a better result in some meaningful way.

And for a while, it seems to deliver.

But then, problems arise that are both unexpected and inevitable.

Because we don’t know what we don’t know.

In psychology, this is related to the Dunning-Kruger Effect, the (much argued over) idea that humans tend to overestimate their abilities when outside their specific areas of expertise.

I can’t speak to the science, but I know from experience that when I’m faced with something new, I often lack the expertise to recognise my… lack of expertise.

The same is true for development teams who try something new and exciting. Here’s how the cycle plays out in digital delivery:

• When starting something new, your team feels highly confident. The project looks simple at first, fueled by incomplete but compelling online examples. Overconfidence reigns.

• Reality sets in. The task, tool, or system is more complex than initially thought. Unexpected problems and delays arise. Confidence plummets and progress grinds to a crawl.

• Slowly, as they hack away at the problem, the team starts to figure things out. They gain efficiency as they become more familiar with the new tool or system.

• Eventually, after mastering the tools and processes, the team reaches the point where they can make accurate predictions and deliver reliably.

Although I’ve exaggerated the cycle for effect, my guess is that many of you will recognise the stages above in some form. Initial overconfidence leads to disillusionment and, finally, a hard-won victory—but only after losing precious time.

This cycle explains why shiny new things can be so disruptive. 

If we aren’t careful, we end up constantly reinventing the wheel… endlessly revisiting stages one and two.

Zero consistency. Maximum stress.

Not to mention unpredictable timelines and unhappy clients.

So what’s the alternative? How can we set up camp in stage four and live there?

Our answer: Accelerators.

What is an Accelerator?

An Accelerator is anything that allows us to work faster, more consistently, or more reliably. It might be a process, a piece of code, a design pattern, or even a piece of infrastructure. 

An accelerator can be something as simple as a consistent folder structure in your Knowledge Management System, or as complex as a full design system (complete with tokens). 

The key thing is this: Accelerators can be reused across multiple projects.

When we create accelerators, we are codifying our expertise, reducing complexity, and setting smart defaults for ourselves.

We are making our work (and lives) consistently easier.

Ten practical examples of Accelerators at work

Let’s look at some practical examples of Accelerators—big and small—culled from our team.

1. The two-character email address

When I need to type my email address out, I use a two-character code (,e) to trigger a snippet in Alfred.

2. Our Project Delivery checklist

Checklists can accelerate progress by reducing the mental load on your team and ensuring that nothing is overlooked. (If you’ve not read Atul Gawande’s book, The Checklist Manifesto, we highly recommend it.)

Here’s the simple checklist we use to sanity-check whether we should start a new project.

3. Easy email templates embedded in our workflow 

Using Google Docs to write articles makes it easy to embed email templates within our workflow. Once the second draft is done, for example, we send a standard email to our outside reviewers to get feedback. A single click opens an email with the recipients and content prefilled. Paste the link, hit send, and you're done. 

4. A consistent folder structure across all platforms

I loved the practical simplicity behind Tiago Forte’s book,  The PARA Method. Forte argues that we can organise our work, thinking, and lives into four categories: Projects, Areas, Resources, and Archives.

In a world where information is often spread across multiple platforms, having a common structure can hugely increase the speed at which things can be found.

5. Template cards on Trello

Templates allow us to build smart defaults into our systems, releasing us from busy work we must do every time (and avoiding the chance that we’ll miss something important).

6. An “accelerated” desktop

If you know the French phrase, “Mise en place,” (putting in place) you’ll understand how seriously professional chefs take the idea of smart defaults. They know that their best work requires every tool and ingredient to be where they expect it to be at the start of service.

Our Content Strategist uses this one-click shortcut (in Keyboard Maestro) to reset his desktop at the start of every session, arranging apps and Chrome tab groups into specific places… because knowing exactly where things are is a huge accelerator.

7. Our design system in Figma

Figma allows us to reuse our design patterns, literally embedding our expertise and experience into the interactions and code.

8. The standard process we follow to deliver client projects

9. The document we fill out after the Discovery Sprint

Every delivery begins with a Proposition Brief, a standard document that puts us and the client on the same page… literally and metaphorically.

10. And a bonus…

Naturally, as we’ve just started writing articles, we have an article template set up in Google Docs. This will develop over time, but its early existence speaks to something more important than any individual example… our Accelerated mindset.

Building an Accelerated-mindset

It’s probable that none of the examples above surprised you. If you work as a developer, I certainly hope that you already have a documented process, use tools like Figma, and develop reusable code.

If you don’t, start there. (I’ll be writing articles that cover each of these things.)

But assuming you do any or all of the above, I’d like to invite you to think bigger. Reusing email validation code is one thing, but what if we could lift and reuse whole sequences?

Here’s an overview of a login sequence we have reused in numerous apps.

What happens when things HAVE to change?

As you’ll have noticed, our examples above include plenty of recent tools and technologies, so let's address an obvious criticism of the argument I’ve been making.

Yes. Sometimes we have to learn new things. And sometimes, the pain of change will be totally worth it. The question is… when do you want to feel that pain?

I’ll tell you when you shouldn’t want to feel it—when you are working on a client project.

That’s why we never (ever) experiment on Customer Code.

Instead, we rely on our code library, design system, and interaction guides. These tools are built from cumulative knowledge across numerous projects, allowing us to deliver quickly, reliably, and confidently every time.

Accelerators will give you the confidence to move fast without breaking things. That’s what we’re paid for. That’s what builds our business.

And because we can deliver so quickly and efficiently for clients, we have the time to experiment (on non-client) code when the business case arises.

Conclusion: The four BIG benefits of Accelerators

In today’s development landscape, every moment counts. As my friend Don Norman says: “The moment you start a project, you are already behind schedule and over budget”. 

Accelerators don't just speed things up—they improve quality and predictability through:

• Speed: By starting with known, stable assets, you avoid the time sink of creating infrastructure from scratch. For instance, a one-click authentication system can save hours, if not days, of development work.

• Predictability: With accelerators, you know exactly how long tasks will take because you’ve done them before. This predictability is invaluable when creating timelines and managing client expectations.

• Cost-Efficiency: Time saved is money saved. By accelerating the delivery process, you reduce the cost of production and boost profitability per project.

And here’s the final benefit. If you allow accelerators to handle the repetitive tasks, you free yourself and your team to focus on what truly matters—the innovation required to make each specific project the best it could possibly be.

Trust me. Consistent, stress-free delivery is the shiniest thing of all.