Startups
Fintech
Healthcare
Manufacturing
Marketplaces
Mortgage
Real Estate
Retail
Sports and Fitness
Telecom and IT
Logistic
SaaS Product
About Us
Blog
Careers
Become A Partner
Contact
+1 (561) 717-2700
+91 96620 35673
About Us
Blog
Careers
Become A Partner
Contact
Enterprise Solutions
Production-grade web applications engineered for enterprise scale complex workflows, integration depth, multi-tenant architecture and the engineering discipline that enterprise platforms actually require.
Learn MoreTurning a Fragmented Loan Workflow Into One Connected Mortgage Platform
The client is a US-based mortgage lender headquartered in California, specializing in Non-QM loan programs and Prime Jumbo lending for borrowers who don't fit a standard underwriting box. When Solvios stepped in, the client's account executives, loan officers, and underwriters were working across a front-end web app and Byte Software's loan origination platform that didn't talk to each other cleanly, and appraisal requests were still being coordinated by hand.
Client
US-Based Non-QM Mortgage Lender
Duration
3 years (ongoing engagement)
Industry
Mortgage Lending (Non-QM & Prime Jumbo Loan Programs)
Country
United States (California)
Tech Stack
- .NET Core •
- MS SQL Server •
- Byte Software API •
- Reggora API •
- TFS •
- WebSockets •
- Microsoft Dynamics
Services
- UI/UX Design •
- Product Development •
- DevOps Solutions •
- AI Consulting Services
The Challenge They Brought to the Table
A US-based Non-QM and Prime Jumbo mortgage lender came to Solvios with a front-end loan application that had grown heavily dependent on Byte Software but never synced with it reliably. Solvios rebuilt the account executive and loan officer experience, integrated Byte and Reggora through their respective APIs, and added a custom pricing engine and real-time notifications. The result is a single web application that loan teams actually use end to end, instead of switching between three disconnected tools.
Front-end user accounts and roles were tightly coupled to Byte Software but fell out of sync when changes were made directly in Byte.
The Approach We Recommended
The client already had a functional back-end web app for its account executives, but growth had outpaced the interface. Byte Software handled loan origination underneath, and the front end was meant to be a faster way in, except the two systems didn't always agree with each other.
Users and roles created in the front end didn't always create matching accounts in Byte, and vice versa.
The Problem That Needed More Than a Quick Fix
None of this could be solved with a patch here and a bug fix there. The front end, Byte, and the eventual Reggora integration needed to be treated as one system with a shared source of truth, which meant rethinking user management, pricing, 1003 handling, and appraisals together.
User Management and Byte Sync
Users and roles were tightly integrated with Byte Software, but frequent changes made directly in Byte weren't reflected on the front end. Account executives and loan officers got locked out when the two systems disagreed about who they were.
A Pricing Engine Nobody Fully Understood
The pricing engine sat at the center of every Non-QM loan decision and needed regular updates to track market changes. The challenge wasn't writing the code, it was understanding an engine that supported over 100 loan programs well enough to touch it safely.
1003 Data Spread Across Systems
The 1003 is the backbone of any mortgage application, and this one carried personal, residential, and employment details across more than 300 fields. That data had to be captured cleanly on the front end and land correctly in Byte, every time.
Appraisal Management Running on Manual Coordination
Appraisal management was handled offline directly through Byte. Once the client partnered with Reggora, the process needed to route between loan officers, underwriters, and account executives without turning into another spreadsheet-and-email chain.
How We Approached It?
Before any code changed, the team spent about a month in stakeholder meetings, mapping exactly how account executives, loan officers, and underwriters actually used the system day to day. That set the baseline for every decision that followed.
Start With the Data Table People Actually Complained About
The old data table was clunky, heavy, and hard to work with, and it was the screen every user touched first. Solvios replaced it with a modern, Angular-supported data table that made day-to-day navigation noticeably faster.
What We Built & Delivered
The finished platform connects the front-end web app, Byte Software, and Reggora into a single working loan environment, with the pricing logic, appraisal workflow, and 1003 handling built to match how the client's teams actually operate.
Byte Software Integration
Byte's APIs and SDK now handle the flow of information between the front-end web application and Byte Software directly, keeping user accounts, loan records, and status updates consistent on both sides.
Appraisal Management (Reggora + Byte)
Loan officers submit an appraisal request once, and the platform routes it to both Reggora and Byte through their respective APIs. A custom Excel-style widget inside Byte gives underwriters a working view of appraisal data as it comes back.
1003 Management
Account executives and loan officers upload the 1003 file and see the data laid out clearly in the interface. Once processed, the same data is stored back to Byte, so nobody re-keys the same borrower details twice.
What Changed After We Shipped?
The engagement moved the client from a patchwork of disconnected tools to a single platform that account executives, loan officers, and underwriters rely on for the full loan lifecycle.
End-to-End - One Connected Loan Ecosystem
Solvios now owns and maintains the client's full loan management ecosystem, with the front end, Byte, and Reggora working as one system instead of three separate tools.
Two-Step - Appraisal Submission Instead of Manual Coordination
Appraisal requests now move through a defined two-step submission to Reggora and Byte, replacing the email-and-spreadsheet coordination the client relied on before.
Real-Time - Visibility Across Every Active User
WebSocket-based notifications mean loan officers, account executives, and underwriters see updates on a shared loan file as they happen, not after the fact.
Single View - 1003 Data Replacing Fragmented Records
The 1003 upload flow gives account executives and loan officers one place to review borrower data instead of piecing it together across systems.
3 Years - Continuous Partnership and Iteration
The relationship has run for three years and counting, with the pricing engine and integrations updated as the client's loan programs and partner platforms evolve. None of this happened as a single release. It came from treating the front end, Byte, and Reggora as parts of one workflow, and fixing the handoffs between them one at a time.
Have a Loan Platform That Needs Its Systems Talking to Each Other?
If your lending platform is stretched thin across a front end, a loan origination system, and a growing list of third-party APIs, that's exactly the kind of integration work we just walked through. We can take a look at what's actually connected and what isn't. Response within 24 hours. No commitment required.
Solvios understood how deep our Byte integration ran before they changed anything. The pricing engine and appraisal workflow are things a lot of teams would have gotten wrong, and they didn't.
How the Engagement Ran
The work happened in phases rather than one long build, which mattered given how much the pricing engine and integrations kept changing underneath the project.
01
Discovery and Stakeholder Alignment
About a month of meetings with account executives, loan officers, and underwriters to map the real workflow before any design or development started.
02
Interface and Data Layer Rebuild
The clunky data table was replaced, and the single-step loan application was redesigned into the 4-step wizard with document upload and chat built in.
03
Byte and Reggora Integration Hardening
The team traced and fixed the account sync gap between the front end and Byte, then built the two-step appraisal submission flow into Reggora and Byte.
04
Pricing Engine and 1003 Workflow Buildout
Engineers worked directly with the client's domain experts to safely extend the pricing engine and build the 1003 upload-and-sync flow to Byte.
Frequently Asked Questions
Integrating a custom pricing engine with loan origination software starts with understanding the engine's existing logic before writing any new code, especially when it supports 100-plus loan programs. The integration typically works through the loan origination platform's API, pulling borrower and loan data to calculate pricing and pushing results back in real time. The harder part is domain knowledge: pricing rules for Non-QM and Prime Jumbo programs change often, so the engineering team needs direct access to underwriting and pricing experts, not just API documentation, to update the engine safely as programs evolve.
Connecting an appraisal platform like Reggora to an existing loan workflow means designing a request flow that satisfies both the appraisal platform's API and the loan origination system's API at once. In practice, this looks like a single user action, a loan officer submitting an appraisal request, that triggers two API calls behind the scenes: one to the appraisal platform, one to the loan origination system. Underwriters then need a working interface, sometimes a custom spreadsheet-style view, inside the loan origination system to manage the data that comes back from appraisals.
1003 loan application data typically spans 300-plus fields covering personal, employment, and residential details, so the sync needs a clear single source of truth. The common approach is to capture and display the 1003 data in the front-end interface first, letting account executives or loan officers review it, then push the finalized data to the loan origination system, like Byte, through its API once the application is submitted. This avoids double data entry and keeps both systems showing the same borrower information without manual re-keying.
WebSockets keep a persistent connection open between the client and server, so updates push to every connected user the moment they happen, instead of each user's browser repeatedly asking the server if anything changed. For a loan file being worked by multiple people at once, an account executive, a loan officer, and an underwriter, that difference matters: polling either lags behind real activity or hammers the server with requests to stay current. WebSockets solve both problems at once, which is why they fit loan status notifications and in-app chat better than a polling-based approach.
Timelines vary with scope, but a realistic approach treats it as phased work rather than one release. Expect an initial discovery period of several weeks to map how loan officers and account executives actually use the system, followed by incremental releases, starting with lower-risk interface changes like navigation and data tables before touching core systems like pricing engines or loan origination integrations. Spreading changes across phases, rather than a single cutover, is what keeps loan officers working through the modernization instead of being blocked by it.
Didn't Find What You Were Looking For?
Get In Touch With Our Experts
