Modern Tax System

Context:
Payroll taxes are one of those things that nobody really cares or thinks about until something goes wrong.

At Paylocity, we process payroll for 40,000+ companies, each responsible for paying and filing taxes across ~13,000 jurisdictions on different schedules. These include both employer and employee taxes, so the stakes are high.

Each payroll run kicks off a chain reaction. Tax liabilities are generated based on the amount, funds are collected, deposits are made, and returns are ultimately filed as a record.

And because we operate under a TPA / POA model with our clients, we don’t just play a supporting role in this process – we own it. If something fails, it’s not just a Product or UX issue, it impacts our business, the client, and the relationship. Things like missed payments, penalties or interest all carry real financial risk.

The Problem:
The legacy system we’d been licensing for years wasn’t built to handle that level of responsibility. it was an expensive, fragmented third-party platform heavily reliant on manual coordination. Different teams owned different stages of the tax lifecycle, but nothing clearly connected them.

In theory, the workflow should:

Tax Liability > Collect Amount > Deposit Amount > File Return

In reality, however, things broke quietly, and we found out too late. A missing EIN. An expired TPA. A company or branch opening in a new jurisdiction that wasn’t fully set up with that tax agency. Small issues were allowed to proceed until they failed, when the cost of fixing them was already high.

Our teams weren’t just doing the work, they were also constantly stopping to investigate, rewind, and recover from failures that could have been avoided in the first place.

Insight:
It became clear we weren’t dealing with downstream problems, we were dealing with upstream issues going undetected.

It turned out that paying and filing payroll taxes aren’t just a series of steps, it’s an interconnected system, and if something is wrong early, it has a domino effect that worsens as it moves forward. So instead of improving individual steps, I asked “What if we could validate tax jobs as they move through the process in realtime and put the brakes on the one with issues the moment they’re detected?”

Approach:
I worked with my PM and Tax Ops partners to map the lifecycle end-to-end and together we identified where failures originated and how they propagated. From there, we introduced controls.

Tax Treasury Flow With Control Checkpoints

Old Workflow

What are controls? They’re systematic, validation checkpoints that exist across the entire payroll tax process. At each phase, MTS would evaluate whether all the right conditions are met before allowing any given tax job to proceed. If something is wrong, the controls system detects it, flags it and doesn’t let it pass.

New Workflow

We wound up with over 90 different controls after our first pass, which meant that there had been dozens upon dozens of things that were historically mucking up the works of a smooth and successful tax processing operation. Yikes.

You. Shall. Not. Pass! …with a control violation

Designing Readiness:
We absolutely wanted to break our reliance on legacy software, but it wasn’t enough to simply replace it with a new version of the same thing. As such, I was adamant about interjecting a new piece into the end-to-end process we named “Readiness”.

Instead of problems appearing to pop up randomly across different tools and portions of the process, everything rolls up into one, centralized place. Paylocity could now operate the payroll tax process holistically instead of piecemeal.

Readiness Dashboard

Teams can immediately see what’s broken, how severe it is, and where to focus. Opening an issue shows exactly what triggered it.

Issue Detail View

An incorrect or missing EIN might not seem like a huge deal, but in this scenario here, it will block filing later, which, in turn, makes collecting the funds from the client and depositing them into agency coffers a moot point.

Instead of finding that out downstream once a filing fails, the system detects and surfaces it immediately. Surfacing the problem isn’t enough, the system needs to help resolve it.

Guided Resolution

MTS clearly explains what needs to be fixed and prompts users take action directly from within the same UI. No digging, switching tools, or guesswork needed.

Reprocessing the Issue

Once a fix is submitted, the system re-validates the tax job against the control that caught it in order to ensure that there won’t be any additional blockers as it moves along.

Resolving the Issue

If the tax job passes without being caught by any controls, the workflow resumes automatically, the user is prompted to work the next issue, and a complete history is captured for troubleshooting and auditing purposes.

This wasn’t just for validation, it was about providing our users with visibility, too. Every issue includes a timeline of what happened, who touched it, what changed and all of that context is carried downstream as the tax job moves onto the next phase in its lifecycle.

Treasury Team Collections Dashboard

When a tax job fails a control, it doesn’t just show up in Readiness, it’s also surfaced to the Treasury Team in their workflow. This allows them to keep tabs on all of their tax-related work, regardless of whether or not it’s blocked by a control violation or proceeding along as intended.

Collections On Hold

Within Collections and Deposits, users can drill into any transaction, but the On Hold view ties directly back to Readiness. It shows exactly what’s blocked, why it’s blocked, and what needs to happen next. This makes it easy to keep clients informed and support Tax Ops without asking around or digging through reports.

Details Page – On Hold Collection

The details page is the final piece of the puzzle. After drilling in, Tax Treasury users can see the full picture, presented in a way that aligns with their mental model. Things like the transaction details, hold reason, audit trail and a breakdown of the individual liabilities within the overall payment are all readily available to them.

Outcome:
This wasn’t just some series of UI and workflow improvements, nor was it simply sunsetting an awful, third-party legacy tool. It was a fundamental shift in how Paylocity was able to process and file payroll taxes.

Work no longer marched blindly forward. Instead, tax jobs were now continuously validated, and issues were caught at the point of introduction rather than at the point of failure.

As a result, our slew of different Tax Ops Teams could work in a far more optimal manner. They spent less time reacting and more time doing performing their duties: collecting funds, making payments and filing returns.

This methodology also enabled us to offload the detection and resolution of issues to a dedicated Tax Ops support team rather than using the valuable time of our more specialized Tax Treasury and Filing users to do so.

Business Impact:
We were able to eliminate a $12M+ annual dependency on a third-party platform from a direct competitor in the HCM space. Moreover, owning the entirety of both the system and operational workflows allowed us to have complete control over how our payroll tax processes were executed and how they could evolve. It built a foundation to optimize and grow upon moving forward, letting us control our fate and turn on a dime should future events dictate the need.

Operational Impact:
Issues are now detected and resolved faster, instead of surfacing at the worst possible points in the lifecycle. By introducing controls upstream, we significantly reduced downstream failures in collections, deposits, and filing.

Teams are no longer spending time piecing together what went wrong across multiple systems. Readiness provides all the necessary context in a single, centralized space making the problem clear and resolution straightforward.

Its framework allows us to layer in additional controls as we continue to operate and grow. The 90 or so we launched with was just the beginning.

Strategic Impact:
Now that we’ve got a system that we actually own and can evolve, one that exists as a single, unified platform, we’re able to adapt workflows quickly, layer in automation where it makes sense, and start building toward more intelligent, data-driven operations.

Instead of being constrained by external tooling, we can now move faster and shape the system based on how our teams actually work and improve how they work over time.

My Role:
I led design across the project, from discovery through system design and delivery. This required aligning Tax Ops, Treasury, and Filing around a shared model of how the system should work. I suggested the need for a controls system and worked closely to help define it’s framework, advocated heavily for and designed the Readiness layer, connecting upstream validation to downstream execution. I helped turn a fragmented, high-risk system into something structured, visible, repeatable, and usable.

Final Thoughts:
This initiative wasn’t just about replacing a legacy system with one we could own or making tax workflows easier. Sure, we did all that, but it was really about making things harder to break.

By introducing tax job validation and connecting our teams through a single, shared system, we shifted from reactive problem-solving to proactive control over one of the most important aspects of our entire business.