Skip to content
BOTTLENECK THEORY
All work

Case study · GarnishMate

Replacing garnishment spreadsheets with a purpose-built payroll application.

An internal application for a county education agency's payroll department that brings calculations, case records, payments, notices, and reporting into one repeatable workflow, with staff-managed settings for rates, thresholds, and reference information.

Built for
County education agency, payroll department
Technology
Go · SQLite · Embedded HTML/CSS/JavaScript · Windows executable

The workflow, before and after

Simplified for illustration.

Before · 4 steps

  1. Calculate in a separate workbook
  2. Track payments across workbook tabs
  3. Re-type case details into Word noticesLoops back
  4. Rules held in staff knowledgeWait

After · 4 steps

  1. Enter earnings for the payroll run
  2. Calculate and review in one applicationAutomated
  3. Record actual withholding to the ledger
  4. Generate notices from the case recordAutomated

A recurring payroll process spread across spreadsheets and documents

Payroll was managing wage garnishments through a multi-tab Excel workbook, a separate calculation workbook, and Word letter templates. Staff worked through withholding calculations, tracked payments and balances, and re-entered case details into employee and agency notices.

The work required care every pay cycle. Different order types used different calculations, employees could have multiple concurrent orders, and changes needed to remain understandable after the payroll run was finished. Much of the process depended on staff knowing which steps to perform and where to find the supporting information.

Finding the bottleneck

The underlying problem was fragmented process knowledge. The spreadsheets held figures, the templates held correspondence, and staff supplied the rules and coordination between them.

I worked with Payroll to understand the actual workflow, including how they handled competing orders, entered earnings, prepared notices, recorded payments, and corrected earlier entries. Those requirements shaped an application built around the department's work.

What I built

I built GarnishMate, a Windows application with a browser interface that centralizes garnishment administration. It brings cases, calculations, payment records, documents, notices, and reports together while keeping the deployment simple enough for a small internal team to maintain.

  • Withholding calculations

    Seven calculation types, configurable rates and thresholds, and allocation logic for concurrent orders. Automated tests reproduce examples from Payroll's existing calculation workbook.

  • Case management

    A searchable register of employees and orders, with district filtering, balances, status tracking, and retained case history.

  • Payroll run workflow

    Review calculated amounts, produce a worksheet, and record what was actually withheld. Database checks help prevent duplicate entries for the same order and run.

  • Traceable payment records

    Payments retain the calculation used at the time. Corrections record prior values, and balances recompute from the ledger.

  • Generated correspondence

    Six notice templates populated from case information, available for printing or download as editable Word documents, with generation recorded in the application.

  • Reporting and reminders

    Views for active cases, payment history, agency and district totals, approaching payoffs, and recurring follow-up work.

  • Practical access and deployment

    Individual sign-ins, a read-only mode for review, and a single executable with a SQLite database, without a dedicated application server or recurring software subscription.

Built for Payroll to maintain

Payroll can update minimum wage, withholding percentages, exemption tiers, payroll tax rates, agency addresses, district information, and supported payroll-run settings through the application. These values are configurable rather than buried in the source code, so staff can maintain them without requesting a developer change or a new application build.

This matters for a tool used repeatedly over time: rates, thresholds, and reference information change. Giving Payroll control over those inputs helps keep routine maintenance with the people responsible for the process. Changes to the calculation logic itself still require development and testing.

GarnishMate supports the existing payroll workflow alongside the agency's payroll system. Staff enter earnings from that system and transfer withholding amounts back manually; the application handles the supporting calculations, records, notices, and review process.

What changed

Payroll now uses GarnishMate in production. A process previously spread across workbook tabs, calculation sheets, and letter templates is managed through one application.

Calculations are implemented consistently and supported by regression tests. Notices draw from case records instead of requiring repeated transcription. Payments and corrections leave a traceable history, and reports make the records easier to review.

The application also captures more of the department's working knowledge in a repeatable process, supporting continuity when responsibilities change hands. Staff can maintain supported rates, thresholds, and reference information themselves, reducing reliance on developer availability for routine updates.

My contribution

I worked with Payroll to map the process and translate its requirements into the calculation engine, case management workflow, payment ledger, correspondence tools, reports, and deployment approach. I also created tests and documentation to support ongoing maintenance.

Let's turn a fragile workflow into a dependable system.

Describe what’s getting in the way, or what you need built. You don’t need a finished spec to start.