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
1
2# test function
3snippet test
4abbr func TestXYZ(t *testing.T) { ... }
5 func Test$ {1:Function}(t *testing.T) {
6 $ {0}
7 }
8


2. EasyMotion plugin
The EasyMotion plugin changed my life. I learned very early on how to jump around in vim, to the bottom of a file/buffer (Shift+g), or to the top of a file/buffer (gg), or down 10 lines (10j), etc. But to move to a very specific place in a file, say the middle of a line in the middle of a file/buffer, required jumping down some number of lines or typing a line number + g then hitting several keys to move over to the middle of the line...
Enter EasyMotion. With EasyMotion, I type <leader>w and the buffer becomes filled with highlighted characters. I then type the first highlighted character closest to where I want to jump and then type a second highlighted character.
To move down to the "container" class name in the "section" element, I type co.
Voila, cursor lands right on the text in the middle of the buffer, saving me a few key presses.
nnoremap <leader>g :call FZFProjectRoot()<CR>
" search from the git root if we're in a git repo
function! FZFProjectRoot()
let project_root = system('git rev-parse --show-toplevel 2> /dev/null')[:-2]
if strlen(project_root) > 0
call fzf#run(fzf#wrap('FZFProjectRoot', {'dir': project_root}))
else
call fzf#run(fzf#wrap('FZFProjectRoot'))
endif
endfunction


nmap <leader>n :NERDTreeToggle<CR>
nmap <C-l>l :NERDTreeToggle<CR>
nmap <leader>f :NERDTreeFind<CR>
5. Tagbar
Tagbar is a plugin that, when toggled, shows a view of the structure and list of tags (class names, function names, constants, variables, and other configured tags) within the current file. And, more importantly, allows you to easily jump between tags within that file.
By default, Tagbar has a dependency on ctags to provide tags integration, and some additional formats can be handled by other providers. Vim-go, for example integrates Tagbar using gotags as the provider.
6. Term search
Lastly, you can search for specific terms in the current buffer by typing "/" (forward slash). So, for example, if I type "/toolbar" and hit enter in my current buffer, it will find all instances of "toolbar" and take me to the first instance. I can now type "n" to move forward to the next instance of the word, or "N" (Shift+n) to go backward to the previous instance.
These six tips can really help increase speed and productivity in vim/neovim. Of course, in order to become comfortable with all of them, one must practice and use them often. After some time, it becomes second nature to use each of them, as everything does with vim/neovim. You'll eventually find yourself flying around at a blistering pace!
September 2, 2021
This is just a simple demonstration on how to use python from within a shell script. Both of the following two python files are imported and functions are accessed from the shell script at the bottom.
new_api_keys_map = {
"consumer1": "abcd-efgh-ijklmnop",
"consumer2": "bcda-fghe-jklmnopi",
"consumer3": "cdab-ghef-klmnopij",
}
def get_new_key_by_name(name):
return new_api_keys_map.get(name, "")
kafka_consumer_secret_replace_map = {
"secret1": {2: "secret-value1"},
"secret2": {2: "secret-value2"},
"secret3": {2: "secret-value3"},
}
def get_kafka_consumer_secret_replacement(name, num):
return kafka_consumer_secret_replace_map.get(name, {}).get(num, "")
#!/bin/zsh
NEW_KEY=$(
/usr/bin/env python3 - <<EOF
from api_key_maps import get_new_key_by_name
key = get_new_key_by_name("${GROUP}")
print(key)
EOF
)
REPLACEMENT=$(
/usr/bin/env python3 - <<EOF
from kafka_secret_maps import get_kafka_consumer_secret_replacement
replacement = get_kafka_consumer_secret_replacement("${GROUP}", ${NUM})
print(replacement)
EOF
)
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
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.
class Node(object):
left, right = None, None
def __init__(self, data=None):
self.data = data
# Binary search tree insertion
def insert(root, key):
# if the root is None, create a new node and return it
if root is None:
return Node(key)
# if the given key is less than the value of the root node,
# recur over the left subtree
if key < root.data:
root.left = insert(root.left, key)
# otherwise, recur for the right subtree
else:
# key >= root.data
root.right = insert(root.right, key)
return root
def constructBST(keys):
root = None
for key in keys:
root = insert(root, key)
return root
def inorder(root):
if root:
inorder(root.left)
print(root.data, end=' '),
inorder(root.right)
keys = [1, 2, 5, 6, 3, 4]
root = constructBST(keys)
inorder(root)
The output we get after running the inorder function on the binary search tree is a sorted list of the raw unsorted 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