Strategy and Solutions
A regional bank’s legacy loan processing system—built on a monolith with nightly batches—struggled with rising applications and evolving rules. Origination, underwriting, decisioning, and boarding shared code paths and data stores; peak loads caused queues; and regulatory findings called out weak audit trails and manual overrides. The bank asked Zymr to modernize for scale, resilience, and compliance while keeping service uninterrupted.
Targets were explicit: handle 3× transaction volume, cut loan processing time by 60%, and pass examinations cleanly—without a risky system freeze.
The project wasn’t a vanity rewrite; it was a survival upgrade. The bank needed throughput, transparency, and trust—on a deadline.
The pain was structural (architecture) and procedural (evidence). We needed modularity for scale and a ledger of decisions for regulators—delivered incrementally.
All functions live in one deployable with nightly ETL to downstream systems. A hiccup anywhere delayed everything.
Spikes from partner channels overwhelmed the intake tier; underwriting rules executed synchronously and blocked threads; queues lacked back-pressure.
Evidence of who changed what, when, and why was incomplete. Manual “workarounds” patched gaps but hurt consistency and raised supervision costs.
Any large refactor risked regression of hard-won edge-case logic—co-applicant flows, jurisdiction rules, income treatments.
The modernization had to be surgical: disentangle capabilities, add elasticity, and strengthen controls without losing the behaviors that made the book perform.
Zymr turned a constrained, brittle system into a scalable, explainable lending platform. The bank processes more loans faster, satisfies regulators, and ships changes with confidence—converting architecture into advantage.
Modernization didn’t just fix pain; it unlocked growth—more throughput, better oversight, and quicker time to yes.
These gains created capacity to innovate safely: new channels, new partners, and smarter models can be added without disturbing the core.
The bank can now scale demand and policy changes without a rewrite—future work is configuration and service expansion, not heroics.
We didn’t “jump” to modernity; we grew into it—service by service, rule by rule—with test evidence at every step and an operational kill-switch when needed.
We mapped services and data dependencies (credit bureaus, fraud services, KYC, pricing, docs). Using a strangler approach, we stood up new services—intake, risk, decisioning, docs—fronted by an API gateway while the monolith continued to serve legacy endpoints.
Core functions became independently scalable services communicating over a message bus. Idempotent consumers ensured retriable processing; sagas coordinated multi-step operations (e.g., underwriting → conditions → appraisal).
Underwriting rules moved into a versioned rules engine with a side-by-side shadow mode before cutover. Every decision produced an immutable audit record: inputs, rule version, output, and overrides with reasons.
Autoscaling policies covered partner spikes; bulk pulls to bureaus became asynchronous; caching and circuit breakers improved resilience to upstream slowness; hot paths were profiled and optimized.
PII/financial data encrypted at rest and in transit; RBAC + MFA enforced; access certifications automated. End-to-end transaction logs created a defensible audit trail. SoD (segregation of duties) was checked in pipelines.
Contract tests stabilized integrations; synthetic loan scenarios validated edge cases per jurisdiction; canary releases allowed gradual traffic shifts; automated rollback protected SLAs.
New services took traffic progressively via routing rules. A feature-flag framework enabled toggling behaviors per channel/state while parity was proven.
The architecture could now breathe with demand, decisions are explainable, and change is controlled. Modernization became a managed process, not a one-time gamble.
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)