Rebuilding PaySimple's Payments Platform
Strategic Challenge
PaySimple's billing system had become a fragmented mix of tools with inconsistent flows and duplicated logic.
We set out to unify it into a single platform that could support all payment types without disrupting $32M+ in annual revenue.
My role
Lead Product Designer for the first phase of the unified payments platform. Led research, strategy, prototyping, and final UI, working closely with product, engineering, and customer-facing teams. Focused on building a scalable foundation for future payment types.
Key outcomes
- $5.5M processed in the first 3 months
- Unified billing into a single platform
- Invoice builder became the primary revenue driver
Context
PaySimple is a small business platform offering payments, billing, and customer management. Over time, the billing experience had become brittle and inconsistent. Invoices were created one way, recurring billing another, and point-of-sale had its own entirely different flow. Each handled core actions like customer selection, tax application, and scheduling differently, creating unnecessary cognitive load for users and slowing engineering velocity.
There were no shared components or patterns to guide design or development. Every new feature required a custom implementation, making it harder to innovate quickly or maintain consistency. Internally, it meant maintaining multiple codebases for overlapping functionality. Externally, it meant customers struggled to predict what would happen when they tried to complete a task.
We needed to create a single, flexible system to unify these flows, one that could support all payment types and scale with the business.
Process
Before we could improve the experience, we had to design a system that was both consistent for customers and scalable for the team. We began by mapping every billing flow in detail, organizing them to expose overlaps, gaps, and redundancies. Seeing it laid out in one place made the duplication impossible to ignore and gave us a clear starting point for consolidation.
We validated the proposed structure through tree testing, which confirmed what we'd seen anecdotally: the old flows were unintuitive, and even experienced users often took inefficient or incorrect paths to complete basic tasks. This helped us refine the information architecture and task placement before any UI work began.
Early design concepts focused on organizing three main factors: Frequency (one-time or recurring), Type (Payment, Invoice, or Payment Plan), and Items. With customers having vastly different mental models for billing, our testing concentrated on finding a pattern that could work universally while remaining scalable for our technical constraints. Through testing, we explored different orderings and combined models, including versions that merged Frequency and Type into a single step. The winning approach had users first choose a combined Frequency + Type option, then select Items.
This structure gave us the flexibility to build Invoices first while maintaining a consistent framework for future payment types. We tested multiple invoice variations and built the version that performed best in user testing. Two rounds of moderated testing with users from multiple industries helped fine-tune the details. We caught small but important issues like unclear button labels and mismatched field behaviors, and resolved them before handoff to engineering. By the time development began, we had validated not just the interface, but the underlying logic and structure.
Solution
The Vision
We set out to create a unified global payment builder capable of supporting every billing scenario: one-time invoices, recurring payments, deposits, installment plans, all built from a shared set of components and consistent patterns. The goal was not just to replace legacy tools but to create a scalable foundation for future growth.
Phase One: Invoices
Invoices were our highest-value billing flow, generating the most revenue in the legacy platform. Starting here allowed us to deliver immediate business value while testing the model for future payment types. The redesigned builder replaced a brittle, inconsistent tool with a flexible, extensible interface. Every aspect of the experience, from customer selection to payment scheduling, was rethought for clarity, efficiency, and consistency.
We built the builder around modular components that could be reused in any payment flow. Elements like tax rows, line item tables, and scheduling selectors were designed once, tested thoroughly, and implemented in a way that allowed engineering to drop them into other billing types without rewriting logic.
The Foundation: Neon Design System
In parallel, we developed Neon, PaySimple's first design system. Neon provided a single source of truth for components, patterns, and code, ensuring that new features would look, feel, and behave consistently across the product. It eliminated the need to rebuild UI from scratch, reduced design and development time, and raised the quality bar by aligning designers and engineers on a shared set of standards.
The combination of a unified payments builder and Neon's component library meant we could scale improvements far beyond invoices. Future phases like recurring billing, deposits, and templates could be built faster, with fewer bugs, and with a consistent experience for customers from day one.
Impact
The launch of the new invoice builder marked more than just a redesign: it was the first step in transforming PaySimple's entire billing platform. Customers immediately felt the difference. The flow was clearer, faster, and more predictable, reducing friction and increasing confidence. Support teams noticed fewer questions about what would happen after sending an invoice, and product stakeholders saw a dramatic decrease in bugs and inconsistencies that had plagued the legacy system.
Internally, the benefits extended well beyond invoices. Engineering teams reused the builder's modular components to accelerate the release of recurring billing, deposits, and saved templates, features that had been delayed for months under the old architecture. The Neon design system quickly became the standard for all new product work, reducing duplication and improving delivery speed across the platform.
Key results:
- $5.5M processed in the first 3 months
- 5,100+ successful invoice payments
- 78% month-over-month growth in invoice volume
- Credit card processing share increased from 49% to 83%
By starting with invoices and building a scalable design system, we not only fixed the most valuable flow but created the foundation for a unified payments platform that could grow with the business.
