About Us
Blog
Careers
Become A Partner
Contact
Connecting People With Technology
Solvios is the leading IT company in the business to give you growth, revenue, and a global 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.
US-Based Non-QM Mortgage Lender
3 years (ongoing engagement)
Mortgage Lending (Non-QM & Prime Jumbo Loan Programs)
United States (California)
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 pricing engine covered more than 100 Non-QM loan programs and needed frequent updates the team could barely keep pace with.
1003 loan application data spanned 300-plus fields and had to be captured once and pushed cleanly into Byte.
Appraisal management was still running offline through Byte, with a new third-party partner, Reggora, added mid-stream.
Multiple users working the same loan file at once had no way to see each other's changes in real time.
The existing data table was clunky and hard to navigate, which slowed down account executives on every single loan.
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.
Account executives and loan officers were occasionally locked out because their Byte account and web app account had drifted apart.
There was no structured process for the 4-step loan application flow; it existed as a rougher, less guided sequence.
The pricing engine's internal logic lived mostly in the heads of a few people who'd worked with Byte the longest.
Appraisal requests depended on manual coordination between account executives, underwriters, and outside appraisal contacts.
There was no real-time signal when another user updated a loan, so teams duplicated work or missed changes.
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.
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.
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.
The single-step loan application process became a 4-step wizard, with document upload integration and a chat widget built in so account executives and loan officers could communicate without leaving the flow.
User accounts worked independently on both sides but drifted out of sync whenever changes happened directly in Byte. It took a few iterations to trace where the sync broke and to stabilize account creation across both systems.
With more than 100 loan programs riding on it, the pricing engine wasn't something the team could guess its way through. Engineers spent real time with the client's domain experts before shipping changes, then kept up with frequent updates as loan programs changed.
Rather than bolt Reggora on as an afterthought, the team built a front-end interface where a loan officer's appraisal request triggers two calls: one to Reggora's API, one to Byte's API, with a purpose-built spreadsheet-style view inside Byte for underwriters to manage the data that comes back.
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'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.
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.
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.
The pricing engine stays current with frequent updates, pulling accurate pricing for each loan program based on the borrower data an account executive or loan officer enters.
WebSockets power live notifications and in-app chat, so when one user updates a loan, everyone else working that file sees it happen instead of finding out later.
The loan application moved from a single dense step to a structured 4-step wizard with document upload built in, cutting down on the back-and-forth that used to happen when something was missed.
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.
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.
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.
About a month of meetings with account executives, loan officers, and underwriters to map the real workflow before any design or development started.
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.
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.
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.
WebSocket-based notifications and chat went live, and the engagement shifted into a three-year-and-counting maintenance and iteration cycle.
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
We'd love to understand what you want to build. The more context you share, the faster we can give you a useful response not a sales pitch, but a genuine assessment of how we can help and what working together would look like.
Solvios is a leading software development company crafting innovative solutions for businesses. We Specialize in custom software, web & mobile app development, and digital marketing. Partner with us to transform your vision into reality and achieve digital success.
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
