Speeding up payment routing delivery without losing flexibility

Background

Scorpex is a global provider for hybrid crypto and fiat payments. The project focused on building a minimalist payment routing system to manage terminal load, transforming complex backend cascading into an intuitive admin tool delivered in just one sprint.

Challenges

The project faced a strict one-sprint deadline for a full production launch with zero room for a complex visual builder.

By stripping away the typical node-based interface, I had to design a minimalist alternative that simplified terminal load management. The goal was to ensure fast implementation without sacrificing routing flexibility or the feature's core business value.

Objectives

Fast delivery: Move from design to a production-ready build in a single sprint.

Lean complexity: Replace the heavy visual builder with a high-speed modular setup.

Retain power: Ensure admin flexibility for complex routing without the dev overhead.

Strategy

Prioritizing Speed over Complexity

With no time for a full research cycle, the strategy focused on stakeholder alignment and technical feasibility to deliver a production-ready tool in a single sprint.

01. Rapid validation via stakeholders

Since end-user research wasn't an option, I conducted "corridor interviews" with key stakeholders. By presenting interactive prototypes with real flow scenarios, we quickly validated the core logic and identified must-have features before writing a single line of code.

02. Replacing the builder with fixed pipelines

A full visual builder was too expensive to develop. We decided to use a modular modal-based setup with a fixed pipeline instead. By removing complex "and/or" operands, we created a predictable flow that is both easier for admins to configure and significantly faster for engineers to build.

03. Constraint-based error prevention

To ensure system stability, I implemented forced limitations when combining different condition types. Instead of letting users create broken logic, the interface actively restricts invalid combinations, reducing configuration errors to zero by design.

Design

01. Modal-based routing modes

To avoid the complexity of a full-scale builder, I introduced a dual-mode modal for redirection. Admins can choose between a simple "direct" redirect or toggle specific cascading parameters like "Terminal capacity" or "Transaction amount." This approach kept the interface clean and allowed for a modular build that was easy to implement within the sprint.

02. Dynamic condition stacking

To maintain full flexibility without a canvas, I enabled infinite condition stacking within each parameter. Admins can define multiple ranges and threshold values using intuitive operators, allowing for highly specific routing logic. This granular control ensures the system handles any edge case while remaining strictly within the modular modal framework.

03. Logic-based error prevention

To ensure the pipeline remains functional, I implemented smart constraints within the grouping logic. The system restricts "Terminal capacity" to a single condition per branch, preventing overlapping rules that would otherwise break the cascading flow. This guardrail ensures that every condition in the pipeline serves a clear purpose and stays reachable.

04. Contextual Round Robin logic

While the backend team suggested adding a separate toggle for Round Robin, I integrated it directly into the terminal selection. By using a multiselect combobox, the system automatically enables load balancing when multiple terminals are chosen. This minimalist approach removes unnecessary UI elements and simplifies the workflow for admins.

05. High-level overview & sidebar management

To keep the main dashboard clean, I used icon-based indicators in the table to show active routing conditions at a glance. Detailed configuration and reset options are managed in a contextual sidebar, allowing admins to edit complex logic without losing the overall terminal context. This hierarchy ensures that monitoring remains fast while deep edits are only a click away.

Outcomes

One-sprint delivery: Moved from initial concept to a production-ready interface in just 5 days, significantly reducing time-to-market.

Zero logic errors: The guardrail system and smart constraints completely eliminated the risk of overlapping or broken routing rules.

Flexible scalability: Despite the minimalist build, the dynamic stacking allows admins to handle complex high-volume transaction scenarios.

Takeaways

Speed as a filter: The strict one-sprint deadline forced me to strip away visual bloat and focus on the core routing logic, resulting in a cleaner product.

Guardrails over builders: I learned that a well-constrained modal system can often be more effective (and much cheaper to build) than a complex, unconstrained visual canvas.

0 likes · 0 views · Oct 15, 2026

Designed a minimalist payment routing admin tool delivered in one sprint, replacing a complex visual builder with constrained modal pipelines and guardrails.