Senior/staff software engineer — building payments infrastructure for the modern web. 15+ years designing and scaling distributed systems, APIs, and fintech platforms.
Entrepreneur, open source contributor, and University of Utah alum.

Senior/staff-level engineer with 14+ years designing and scaling distributed systems, APIs, and payments infrastructure. Most recently focused on building deterministic and idempotent systems for payment rails including ACH, RTP, FedNow, and bank account services. I've led engineering teams and co-founded multiple companies across fintech, real-time data pipelines, e-commerce, and SaaS.
| Name | Brandon Johnson |
|---|---|
| Location | West Jordan, Utah |
| Most Recent Role | Sr. Software Engineer |
| Education | B.S. Accounting (Information Systems emphasis), University of Utah |
| Specialties | Payments, Distributed Systems, Backend Engineering, Product Engineering |
| Languages | English, Portuguese |
May 28, 2026
Eleven engineering roles over seventeen years, ranked by how much they actually shaped how I think.
I have had jobs that looked important on paper and barely changed me, and jobs that looked ordinary from the outside and quietly rewired how I think. This is not a ranking of companies, coworkers, compensation, or titles. It is a ranking of what each stop taught me. That makes it subjective, a little unfair, and probably the only useful way to do it.
First jobs matter because they turn possibility into evidence.

Green PolkaDot Box was my first actual software job. I had already been writing code as a systems administrator, mostly because I kept finding processes that deserved to be automated, but this was different. This was a job where the work itself was programming. Magento, PHP, catalog modules, sales modules, enterprise migrations: all of it felt like being handed a map in a language I could almost read.
It lands in E tier not because it was unimportant, but because the lesson was narrow and foundational. It taught me that I could do the work. That is a huge thing to learn once. After that, the craft had to get bigger than proof of entry.
The lesson was simple: I was allowed to call this my work now.
Confidence is a real career asset, but it is only the starting line. This job turned programming from something I could do into something I could be hired to do.
Owning the whole problem teaches faster than owning a clean slice.

Apptys was messy in the most educational way: client work, sales, finance, hiring, architecture, deployments, outages, estimates, and the emotional weather of running a small agency. I learned software as a business system there, not just as a technical artifact.
Owning the full loop taught me that software quality includes expectation-setting, delivery pressure, business tradeoffs, and trust. The code was only one part of the system.
A great team can teach you culture while an immature stack teaches you engineering discipline.

Clearlink was an amazing cultural experience. The team was sharp and generous, the managers were excellent, and engineers were treated like the work mattered because it did. I loved the work I did there. The sales order system supported hundreds of sales associates, processed thousands of orders, talked to phone systems, brand partner APIs, and payment flows. The stakes were real, and the people around the work made it a genuinely energizing place to grow.
The C tier is not a people grade. It is about the maturity of the technical environment I was learning inside. The stack still had a lot of growing up to do: legacy PHP that had to be handled carefully, SVN-era workflows, and production paths that made staging feel optional. That contrast was useful. It gave me a vocabulary for why source control, environments, testability, and release discipline are not process theater. They are how great teams protect important systems from depending on everyone having a perfect day.
Clearlink taught me two things at once: how good a workplace can feel, and why technical maturity matters.
Culture can make hard technical environments feel energizing, but good culture deserves good engineering guardrails. I started to understand release discipline as a way of protecting both systems and people.
Technical leadership starts where implementation details meet responsibility.

Guidance Solutions was a bridge from senior developer to technical lead. Large Magento projects, client-facing decisions, project managers, scrum meetings, and technical strategy all forced the same lesson: architecture is not just what you build, it is what you can explain and defend.
Technical leadership is not just being right in private. It is making the strategy clear enough that clients, project managers, and engineers can all move with confidence.
Product engineering made the work feel less like code and more like leverage.

Cricut was the first job where the software felt connected to something people could hold in their hands. APIs supported Design Space, mobile apps, embedded devices, e-commerce, and enough surrounding systems that the stack looked less like a tidy diagram and more like a working city.
That changed how I thought about quality. A backend endpoint was not just a contract between services; it was part of a chain that ended with someone making a card, a classroom project, a small business product, or a gift. The work had a consumer product gravity to it. You could not hide behind internal correctness. The experience had to survive contact with real people.
The code was successful only if it helped the machine, the app, and the person agree.
Product engineering made quality feel tangible. A correct API still had to support a real customer trying to make something with a real device.
Scale turns preferences into consequences.

Banjo was the first time I felt real infrastructure scale pressing back. Real-time data pipelines. ML analysis. REST and GraphQL APIs. AWS spend that moved from already-large to genuinely enormous. The numbers were not trivia; they changed the shape of engineering judgment. A casual decision could become expensive. A missing feedback loop could become operational drag.
It also changed my sense of leadership. By 2020 I was leading six engineers, and the job was no longer just to solve hard problems personally. It was to make the team sharper, calmer, and more coherent in the presence of systems that could not be held in one person's head.
At scale, taste stops being aesthetic and becomes operational.
Scale made engineering judgment measurable. Architecture, observability, cost, and team clarity stopped being preferences and became operating constraints.
A useful product idea still needs market pull and founder alignment.

REDfolio sits low because the lesson was more about product-market fit than engineering growth. Co-founding a SaaS company for real estate development sounded, on paper, like the most senior version of my career: director title, ownership, product vision, big domain, big responsibility.
But a product can be well-intentioned and still not have enough pull. We built useful foundation, but the market signal, customer urgency, and founder-product alignment never became strong enough to turn the company into one of the jobs that reshaped my engineering instincts. The lesson was not that the idea was bad or that the work was wasted. It was that durable products need more than a plausible problem and a capable build.
A product can make sense on paper and still not have enough gravity in the market.
Product-market fit is not a checkbox you earn by building the first version. It is a continuing signal from customers, the market, and the team's own alignment with the problem.
Short stops can be useful without becoming chapters.

Lucerna Health was brief: ETL pipelines, REST APIs, and some frontend work in the healthcare data world. It added useful reps, especially around data movement and application support, but it did not stay long enough in my system to become a major inflection point.
Even a short chapter can sharpen a muscle. This one added practical reps around moving data cleanly and supporting the applications that depended on it.
Payments, Go, Kubernetes, and infrastructure became a real center of gravity.

The first Moov run belongs in S tier because it felt like finding my lane. Infrastructure and ACH work gave me the blend I had been circling for years: backend product engineering, distributed systems, operational discipline, Go, Kubernetes, and the kind of payments problems where correctness has teeth.
I found the center of gravity I kept coming back to: payments infrastructure, backend systems, operational correctness, and the kind of engineering where details have financial consequences.
The work was not just building features; it was owning the shape of the product and the stack.

Nerd United was a leadership-heavy season. Architecture, quality, final technical calls, and team direction all lived close together, which made it less about proving I could build and more about helping the right thing get built by more than one person.
Leadership changed from making decisions to making decisions travel well. The work was getting architecture, team direction, and execution to reinforce each other.
Coming back made the work stronger, but the first pass had already changed the trajectory.

The second Moov stint is the ranking that probably needs the most explanation. It was recent, senior, and technically strong. I worked across bank rails, Core, and Platform Cards. I led API versioning across more than sixty services. I helped build an iOS SDK for Tap to Pay. I worked on ACH, RTP, FedNow, and bank account services.
So why B? Because the ranking is about how much the job changed me, not how impressive the work sounds afterward. This round used a lot of instincts the first Moov stint had already built. It refined them, stressed them, and gave them more surface area, but it did not redraw the map in the same way. Sometimes seniority is evidence of previous transformation, not the source of a new one.
The work was stronger than before; the lesson was quieter.
Senior work can be more about refinement than reinvention. This chapter strengthened instincts I already had: API evolution, platform stewardship, and patience with long-lived systems.
The strange thing about ranking a career this way is that the list refuses to match the resume. The founder title is not automatically S tier. The shortest job is not automatically meaningless. The more recent senior role is not automatically the most formative. What matters is whether a job left behind a new instinct. Some taught me how to build. Some taught me how systems fail. Some taught me what kind of work I should keep choosing. That is the tier list I actually care about.
April 21, 2026
Three things that stuck from Intermediate Accounting, twenty years later.
One of the most useful classes I ever took for software engineering wasn't a CS class. It was Intermediate Accounting.
I decided to major in accounting at the University of Utah with an emphasis on Management Information Systems. Twenty years in, working on payment systems for a living, I've realized how important that decision was. Here are three specific things that actually stuck.

In accounting school, the thing that bent my brain the most wasn't debits and credits — it was the accrual principle. Revenue gets recognized when it's earned, not when the cash shows up. An expense belongs to the period it was incurred, not the period you wrote the check. Time and cash are two separate axes, and mixing them up is how books get cooked.
Years later, at Nerd United, we were processing large purchases of blockchain nodes over a parallel L1 Ethereum network. Transactions finalized on-chain quickly most of the time — but purchases made near the end of a month had a way of slipping across the period boundary. A sale initiated on the 31st could finalize on the 1st, and our monthly reports would quietly drop it into the wrong bucket.
It was the matching principle wearing a blockchain costume. The fix wasn't technical — it was recognizing which timestamp defined the period, then designing around that, not around whenever the chain happened to confirm.
It was the matching principle wearing a blockchain costume.

Accountants have a rule: you don't erase anything. When something's wrong, you don't change the entry — you post a correcting entry right after it, with its own date and reason. The history is the point. But there's a second, quieter rule: the history has to be legible. A locked filing cabinet is not an audit trail.
At Moov, we had genuinely great observability for most of the platform — OpenTelemetry, rich traces, persisted events, most of the important things queryable and reproducible. But a handful of edge-case sandbox ACH flows were black boxes. Events were stored but not queryable; logs didn't carry enough context to reconstruct what had happened. I spent hours digging, backfilling logs, and adding traces until the gap closed.
Keeping history isn't the hard part. Keeping history that can be read — by you, by the next engineer, by future-you at 2 AM during an incident — is. An audit trail nobody can follow is a liability with extra storage cost.
An audit trail nobody can follow is a liability with extra storage cost.

One of the deepest habits accounting gave me is reconciliation — the practice of proving a number by reaching it two different ways. If the two answers don't match, something is wrong, and you don't move on until you know why.
At Moov, when an incident caused data corruption — transactions in the wrong state, amounts or timestamps that needed repair — the fix itself was never the whole job. Every remediation query was bracketed: check queries first, to establish the current state and the expected scope of the change. Then the update, inside a transaction. Then check queries again, before commit, to confirm the change matched the plan — no more, no fewer. If the numbers didn't agree, I rolled back and started over.
That's just reconciliation, applied to a database instead of a ledger. Same posture: measure, change, re-measure, and refuse to move on until both sides agree.
That's just reconciliation, applied to a database instead of a ledger.
Those are three things that actually stuck: a sense for where time lives in a system, a refusal to let history disappear, and a habit of proving a number before I trust it. None of them came from a CS textbook. All three have earned their keep more times than I can count. The degree turns out to have been an engineering degree, too. I just didn't know it at the time.
February 4, 2026
I always enjoy reading these, so here's mine for 2026: practical, ergonomic, and tuned for staying in flow.
My setup goal is simple: reduce friction and protect focus.
If a tool helps me move faster with less context switching, it stays. If it adds complexity without payoff, it goes.
I spend a lot of time at my desk, so comfort and ergonomics come first.
Nothing here is "hype gear"—it's all about sustainability for long coding sessions.
I use Neovim, and one of my big recent changes was moving from VimScript to Lua.
I'm now fully on "true Neovim," and it's been worth the migration.
I try to keep my editor setup powerful but intentional: fast startup, clean defaults, and tools that genuinely earn their spot.
My terminal setup is:
I've built up hundreds of shortcuts over time to run common commands quickly.
For me, this is one of the biggest productivity multipliers in my workflow.
I keep Git pretty lightweight:
The goal is to make collaboration smoother and reduce "what happened here?" moments later.
I use AI as a coding partner, not autopilot.
Main tools in rotation:
I use them for exploration, drafting, refactoring, and unblocking—but still validate logic and edge cases myself.
A few habits that consistently help:
Current upgrades in progress:
That's where my setup stands right now.
It's always evolving, but this is the stack that helps me ship reliably in 2026.
June 9, 2022
Six small navigation habits that make Vim and NeoVim feel less like a text editor and more like an instrument.
I've been a heavy Vim and NeoVim user for more than 10 years. For a long time I still kept one foot in the JetBrains world because GoLand, PyCharm, IntelliJ, and RubyMine had debugging features I relied on. After moving fully into NeoVim, especially with vim-go and delve, I started feeling much faster.
These are the six navigation tricks that have helped me the most over the years.
The NeoSnippet plugin lets you define small templates for common code, or use predefined snippets for many languages. The default Go snippets include a test function template like this:
1# test function
2snippet test
3abbr func TestXYZ(t *testing.T) { ... }
4 func Test${1:Function}(t *testing.T) {
5 ${0}
6 }Type test to activate the snippet, then use Ctrl+k to jump through each placeholder.



The EasyMotion plugin changed how I move through buffers. Built-in commands like gg, Shift+g, and 10j are useful, but jumping to a precise spot in the middle of a visible line can still cost several keystrokes.
With EasyMotion, I type <leader>w, the buffer fills with highlighted characters, and I type the two-character target closest to where I want to land.


FZF is a command-line fuzzy finder, and FZF.vim brings that search flow into Vim. I use this function in my init.vim so <leader>g searches from the Git project root when possible.
1nnoremap <leader>g :call FZFProjectRoot()<CR>
2
3" search from the git root if we're in a git repo
4function! FZFProjectRoot()
5 let project_root = system('git rev-parse --show-toplevel 2> /dev/null')[:-2]
6 if strlen(project_root) > 0
7 call fzf#run(fzf#wrap('FZFProjectRoot', {'dir': project_root}))
8 else
9 call fzf#run(fzf#wrap('FZFProjectRoot'))
10 endif
11endfunction
NERDTree is a Vim file explorer. It is not always faster than the standard explorer, but it gives me a clear visual map of a project, and it works nicely with search and motion inside the tree buffer.

I keep NERDTree closed by default, then use mappings for toggling it or opening it at the current file.
1nmap <leader>n :NERDTreeToggle<CR>
2nmap <C-l>l :NERDTreeToggle<CR>
3nmap <leader>f :NERDTreeFind<CR>Tagbar shows the structure of the current file: classes, functions, constants, variables, and other configured tags. The real value is jumping between those tags without scanning manually.
By default, Tagbar uses ctags, and some language ecosystems can provide richer tag support. Vim-go, for example, integrates Tagbar through gotags.
The last habit is plain Vim search. Type /toolbar, press Enter, and Vim jumps to the first match in the current buffer. Then use n to move forward and N to move backward through matches.
These habits are small on their own, but together they change the feel of the editor. Once they become muscle memory, moving through a project starts to feel nearly frictionless.
September 2, 2021
A small pattern for calling Python helpers from a shell migration script without turning the shell script into a data file.
This is a simple demonstration of how to use Python from within a shell script. Both Python files below are imported and their functions are accessed from the shell script at the bottom.
Keep the Python side boring: plain dictionaries, small lookup functions, and empty-string fallbacks when a value is not configured.
1new_api_keys_map = {
2 "consumer1": "abcd-efgh-ijklmnop",
3 "consumer2": "bcda-fghe-jklmnopi",
4 "consumer3": "cdab-ghef-klmnopij",
5}
6
7def get_new_key_by_name(name):
8 return new_api_keys_map.get(name, "")1kafka_consumer_secret_replace_map = {
2 "secret1": {2: "secret-value1"},
3 "secret2": {2: "secret-value2"},
4 "secret3": {2: "secret-value3"},
5}
6
7def get_kafka_consumer_secret_replacement(name, num):
8 return kafka_consumer_secret_replace_map.get(name, {}).get(num, "")The shell script can ask Python for the values it needs and keep the rest of the migration flow in zsh.
1#!/bin/zsh
2
3 NEW_KEY=$(
4 /usr/bin/env python3 - <<EOF
5from api_key_maps import get_new_key_by_name
6key = get_new_key_by_name("${GROUP}")
7print(key)
8EOF
9)
10
11 REPLACEMENT=$(
12 /usr/bin/env python3 - <<EOF
13from kafka_secret_maps import get_kafka_consumer_secret_replacement
14replacement = get_kafka_consumer_secret_replacement("${GROUP}", ${NUM})
15print(replacement)
16EOF
17)February 5, 2021
I often take lessons from sports for personal development in business and in my personal life. One thing I recently recognized is that Competitiveness is a drive that must be team-oriented.
For example, if a superstar on a basketball team is ultra competitive, but less interested in team success and more interested in personal accolades and scoring the most points, that team is rarely successful. On the other hand, if that same superstar learns to become more interested in the success of the team, then that team has a much greater chance of having success.
The same goes for teams in business. I've been on teams where certain individuals are more interested in their own personal career growth and their own accolades and show zero interest in the success of the team as a whole. Those teams were almost always much less successful than teams whose individual members all cared about the success of the team as a whole.
I've tried to take that lesson with me to every team I am part of, and try to quickly correct myself whenever I find myself seeking personal attention or accolades ahead of my team. I also try to quickly take ownership for team failures and am quick to recognize my team for team or individual successes.
November 9, 2020
A compact walkthrough of building a binary search tree and reading it back in sorted order.
Binary trees are encountered often in programming. It's a very simple and efficient data structure that can be used to solve many problems in software systems.
For example, binary trees are used for decision trees, sorting, database indexing, data compression, blockchains, search, and many other applications in software.
An inorder traversal over a binary search tree visits the left branch, then the current node, then the right branch. With a valid BST, that gives us the values in sorted order.
First, create a Node class. Each node can hold up to two children, plus the value stored in the node.
1class Node(object):
2 left, right = None, None
3
4 def __init__(self, data=None):
5 self.data = dataThe insertion function compares each value with the current node and recurs into the left or right subtree.
1# Binary search tree insertion
2def insert(root, key):
3
4 # if the root is None, create a new node and return it
5 if root is None:
6 return Node(key)
7
8 # if the given key is less than the value of the root node,
9 # recur over the left subtree
10 if key < root.data:
11 root.left = insert(root.left, key)
12
13 # otherwise, recur for the right subtree
14 else:
15 # key >= root.data
16 root.right = insert(root.right, key)
17
18 return rootConstruct the tree from a list of keys, then traverse it inorder to print the sorted sequence.
1def constructBST(keys):
2 root = None
3 for key in keys:
4 root = insert(root, key)
5
6 return root1def inorder(root):
2 if root:
3 inorder(root.left)
4 print(root.data, end=' '),
5 inorder(root.right)1keys = [1, 2, 5, 6, 3, 4]
2
3root = constructBST(keys)
4inorder(root)The binary search tree from the constructBST function looks like this:
Binary Search Tree
1
\
2
\
5
/ \
3 6
\
4The output after running the inorder function is the sorted version of the raw input list:
1 2 3 4 5 6
I'm a Lead Software Engineer with over 15 years of experience. I'm from West Jordan, Utah
| Name | Brandon Johnson |
|---|---|
| Current Role | Senior Software Engineer |
| Organization | Moov Financial |
| Location | Fully Remote |
| Website | https://moov.io |
| Personal Public GitHub | https://github.com/darwinz |
Brandon contributed across multiple teams — bank rails, Core, and Platform Cards. On the Core team, he led an initiative to version APIs across 60+ microservices, enabling safe API evolution at scale. On the Platform Cards team, he led development of an iOS SDK for Tap to Pay. He also developed and evolved backend integrations for ACH, RTP, FedNow, and bank account services as part of Moov's payments platform.
As lead software engineer, Brandon was the tech lead for software development projects. Brandon led a team of software engineers, and directed the development of the company's software products. He was responsible for the overall architecture of the software, and for the quality of the code. He also drove decisions related to technology initiatives and had the final say for technical decisions related to sofware projects.
Brandon was a lead for an infrastructure team and an ACH team. He was lucky to have a good blend of software feature development with Golang plus infrastructure and devops work.
Brandon developed ETL data pipelines and REST APIs that support internal and client-facing applications. He also built some client-side (frontend) features.
REDfolio is a SAAS company providing a process and portfolio management solution for real estate developers, helping real estate development companies through the pre-development, construction, and operation stages.
Brandon developed real-time data pipelines enabling ML analysis and in-product features and developed RESTful and GraphQL APIs at scale for customer-facing products (AWS spend per month was $450,000 and reached over $1M per month). Brandon became a team lead in 2020 and led a team of 6 engineers.
Brandon worked on several software projects spanning a variety of tech stacks, including Magento (PHP), Python, Node, Angular, Drupal, and WordPress. Projects included: REST APIs that support Cricut’s award-winning DesignSpace software and mobile apps, APIs that support interaction with Cricut embedded devices, a Magento shopping cart.
Full-service software and web development agency, co-founded by Brandon, specialized in custom e-commerce and application development with PHP, Magento, Wordpress, Big Commerce, WooCommerce, Ruby on Rails, Linux, iOS, and Android. Brandon was involved in every aspect of the business, from sales and finance to client interaction and hiring to project planning and management to software architecture and development.
Responsible for developing overall technical strategy and overseeing development for large-scale, high traffic external client projects. Technical lead was a staff-level or lead-level IC role with additional responsibilities related to client interaction and technical leadership over project implementations. Tech leads also work closely with project managers and lead scrum meetings.
Brandon worked with a team to develop and maintain a robust sales order management system that is used by Clearlink's 800+ sales associates and is integrated with several other software systems, such as the company's inbound sales phone system and its brand partner APIs. Thousands of orders across 15+ nationwide brands and credit card payment transactions are processed through the system and sent to brand partners each day.
Brandon worked with a small team in the development of a heavily customized implementation of Magento, adding key features and customization to the Customer, Catalog, Sales, and other modules. He also helped with a migration from Magento Community to Magento Enterprise.
Brandon was responsible for all network systems, data, security, and computer systems across two states - Utah and Nevada. He also often found ways to make improvements to various systems and processes, which provided opportunities to develop solutions by writing code and building software.
Activities and societies: Sigma Gamma Chi, President of Encore Show Choir
Double-majored during my final year-and-a-half. Some courses included Database Management Systems (with advanced SQL), Web Programming with Java.
Credential ID LF-wp73kwelu5
https://www.credly.com/badges/ea06137c-8026-417f-82d1-6a939fe87a5e/public_url
Credential ID 3adb8720bcab
https://www.hackerrank.com/certificates/3adb8720bcab
Credential ID 166147
https://www.certmetrics.com/amazon/public/transcript.aspx?transcript=9WD84HQK21VQ1NGG
Credential ID 2bb14da6fc45
https://www.hackerrank.com/certificates/2bb14da6fc45
Credential ID ZEND022247
https://www.zend-zce.com/en/yellow-pages/ZEND022247
Reach out if you're interested in networking, or if we can benefit each other in some way.
Address