No major transformation comes without challenges. The Loan Store’s foray into RPA encountered several hurdles along the way, from technical issues to human factors. However, what sets this case apart is how TLS anticipated and addressed these challenges with effective solutions. Here we discuss the key challenges faced during implementation and the strategies TLS used to overcome them:

1. Process Complexity and Exceptions

Challenge: Mortgage processes are inherently complex. They involve multiple decision points, conditionals, and exceptions. One concern was whether RPA could handle all the nuances, or if the bots would break when encountering a scenario they weren’t scripted for. For instance, what if a document had a format the IQ Bot wasn’t trained on? Or what if a particular loan product had a unique step not accounted for? Early automation efforts in any company can stumble if the process isn’t well-understood or if exceptions aren’t planned for leading to bots that work 80% of the time and fail 20%, which can be disruptive.

Solution: TLS tackled this by thorough process mapping and using AI for flexibility. They spent time upfront mapping out the processes in detail, identifying as many branches and variants as possible. The partner leveraged its mortgage domain experience to foresee uncommon scenarios. Additionally, by using IQ Bot with pre-trained models, the solution had some built-in intelligence to handle variability in documents (where purely rule-based bots might fail). During testing phases, they deliberately threw diverse cases at the bots to refine them. For any scenario that truly couldn’t be automated, they designed clear exception-handling paths: the bot would notify a human and gracefully handoff the case. This prevented the system from getting stuck. Essentially, TLS started with processes that were rule-based enough, and for semi-structured tasks they augmented RPA with AI. The result was a high STP rate, implying they managed to account for most complexity, and the remaining edge cases were manageable. The lesson for CIOs/CTOs is to combine RPA with AI for processes that involve unstructured data or lots of variation as Brandi Shoemaker noted, “Designing complex solutions, like adding IQ Bot for data extraction to existing RPA, is where you see the highest level of benefits.”​

This approach directly addressed complexity challenges.

2. Clear Goals and Scope Definition

Challenge: A common pitfall in RPA projects is lack of clear goals or automating the wrong processes (ones that don’t yield value). TLS needed to ensure it focused on high-impact areas and had well-defined success criteria. Without clear goals, projects can meander, stakeholders lose interest, or you automate something and later wonder if it was worth it a scenario seen in some failed projects where “organizations…automate the wrong ones [processes] and run into roadblocks”​.

Solution: TLS leadership from the outset set specific goals: e.g., reduce turn time by 25%, double productivity, etc., which we know they tracked and achieved. They also carefully selected which processes to automate by evaluating pain points (using metrics like how much time staff spent on each task, error rates, etc.). They prioritized processes that were repetitive, high volume, and rule-based the classic RPA sweet spot such as document generation and data entry tasks. Lower-volume or highly judgmental tasks (like underwriting decisions) were deliberately set aside for later (as seen in their “future” plans)​.

By scoping the project to the right tasks, they ensured maximum ROI and quick wins, which built momentum. Additionally, having the COO, CFO, etc., aligned on these goals meant there was top-down support and clarity. They knew what success looked like (the key metrics), so they could course-correct during the project if those weren’t being hit. This focus addressed the first common reason for RPA failure (lack of goal setting) identified by Techaisle​.

TLS essentially did the opposite: set goals, communicated them, and measured them.

3. Employee Adoption and Change Resistance

Challenge: Introducing RPA can create fear among employees about job security. Even if not fear, it’s a significant change in how people work. TLS risked some employees possibly resisting the new tools (not cooperating with training, or even subtly undermining by reverting to manual ways if they didn’t trust the bot output). Also, shifting roles from doing tasks to monitoring bots requires a mindset change and new skills. This kind of organizational change needs careful management to avoid morale issues or loss of key talent. We saw earlier that many SMBs introduce RPA to their workforce without preparing them for the change, leading to disillusionment​

TLS had to avoid this by bringing their team along on the journey.

Solution: TLS executed a strong change management program. They involved employees early, explaining that RPA is there to help, not replace. By emphasizing the retention of the “valuable employee base” and actually standing by that (no layoffs due to RPA)​, they gained trust. They also provided training to upskill staff into new roles (e.g., learning to interpret bot reports, handle exceptions). In essence, they treated the implementation as not just a technology project but a people project. They might have identified champions within the team employees who were tech-savvy or enthusiastic to advocate the change to peers. Given the positive outcomes (less tedious work, etc.), once bots started operating, even skeptics likely saw the benefit (“this report came in and I didn’t have to spend my evening doing it nice!”). Regular communication, as noted, and highlighting successes (like acknowledging how bots made someone’s work easier or how an employee contributed to improving a bot’s logic) also helped. By the time RPA was fully rolled out, employees were adapted to the new normal and perhaps couldn’t imagine going back. The success here is reflected in the absence of any reported pushback; instead, we have quotes like staff focusing on higher ROI work​, indicating acceptance. The broader takeaway: TLS managed change by being transparent, reassuring, and enabling employees, turning potential resistance into support.

4. Integration with Legacy Systems

Challenge: TLS had to integrate RPA with its existing loan origination and ancillary systems, some of which might be legacy or not designed for automation. Integration challenges include dealing with interfaces that might change (for instance, if a LOS gets an update that changes screen layouts, bots can break), or ensuring the bots don’t interfere with human users (like not locking records that a person is also trying to edit). Also, any downtime or performance issues in systems could affect bot performance and vice versa. Ensuring data integrity when multiple “actors” (bots and humans) access systems concurrently was a concern. Essentially, the CTO had to ensure that adding bots wouldn’t destabilize IT systems or require unsupported modifications.

Solution: Using RPA itself was part of the solution here, since RPA by nature is a non-invasive integration tool. The bots used the front-end of applications just like a user would, so no deep system changes were needed. This is likely one reason TLS chose RPA over, say, custom coding integrations. They also tested bots in off-hours and gradually increased their operation to ensure no system overload. If TLS LOS could only handle a certain number of sessions, they might have scheduled some bot work at night to balance load. The mention that the solution “seamlessly integrates with common loan origination” systems​ suggests that they had pre-built connectors or best practices for TLS specific LOS. Many mortgage lenders use standard systems (Encompass, for instance); they likely had experience automating those, so they knew how to avoid pitfalls (like how to reliably find fields on screens, or use APIs if available). They also implemented a robust audit and control framework​, meaning integration wasn’t just doing tasks but also verifying them. For every action a bot took in a legacy system, it probably read back the data to confirm or logged the transaction ID. This way, TLS had confidence that bots did what they were supposed to and didn’t, say, drop data. Additionally, involving IT early to allocate proper environments (ensuring bots had user accounts with appropriate permissions, etc.) was done to integrate smoothly. The result: TLS encountered no major integration hiccups reported, implying the approach was effective. A caution for others is to thoroughly test bots with legacy apps and possibly work with vendors (like TLS did with the partner who knew AA’s capabilities and mortgage systems) to mitigate integration risks.

5. Ongoing Maintenance and Support

Challenge: RPA is not a “set and forget” solution. Bots can fail if something in the environment changes e.g., a UI update, a new type of input, or even if an external site is down. Without proper support, a broken bot can halt a process and cause chaos. One of the top reasons RPA projects fail is “high cost of support in case of RPA script breakdown”​.

If TLS didn’t plan for maintenance, they could face issues like a bot failing at midnight and work piling up until someone fixes it next morning. Also, updating bots when processes change (like regulatory changes requiring new forms) is necessary. So maintaining automation is an ongoing effort and challenge.

Solution: TLS mitigated this by the nature of its Automation-as-a-Service agreement. They provided continuous support, likely including monitoring of bots and quick fixes. As mentioned, providers often include a block of support hours​ or even guarantee a certain uptime. This meant TLS had experts on call to handle any bot malfunctions. Internally, TLS also trained some staff on how to reset bots or handle minor issues, so small hiccups could be resolved immediately. Moreover, the bots were designed to be resilient: using checkpoints and try-catch logic, for example. If a bot fails to log into a system, maybe it retries after 5 minutes and alerts if still not working thereby handling transient issues gracefully. The combination of good design and external support kept maintenance costs low for TLS. Financially, this saved TLS from the common scenario where companies spend a lot post-implementation to keep bots running. By outsourcing much of that, TLS converted it into a predictable service cost, which was likely factored into their ROI already. This challenge was turned into a non-issue in day-to-day ops TLS operations team could trust the bots to run, and if something went wrong, they had a safety net. The approach is a lesson: plan for support from the start, whether through training or contracts, to sustain automation success.

6. Regulatory Compliance and Security

Challenge: In automating processes that handle sensitive financial and personal data, TLS had to ensure that the RPA solution met all security and compliance requirements. Bots accessing borrower data had to be as secure as a human employee accessing it. There could be questions like: do we need to mask any data? Are bot actions compliant with SOC audits? Could a bot inadvertently do something that violates a rule (like send the wrong disclosure)? Regulators don’t yet have explicit RPA guidelines, but the company must ensure automation doesn’t create a loophole in controls.

Solution: TLS addressed compliance by embedding it into the automation design. Every automated step was mapped to regulatory requirements to ensure nothing was missed in fact, bots were used to enforce compliance (like disclosure timing). The robust audit logs mean there’s a clear trail of every action​, arguably better than a manual process where someone might forget to document something. For security, TLS likely worked with their IT security team to treat bot credentials with the same care as human credentials: using secure credential vaults for passwords (Automation Anywhere has credential vault features), giving least privilege access to bots, and monitoring bot activities. Since bots follow scripts exactly, there’s less risk of malicious behavior, but TLS would still ensure any data outputs (emails sent by bots, etc.) were secured. They might have also updated their policies to include RPA for example, change management policies so that if a system screen changes, IT notifies the RPA team to update bots in tandem. Essentially, TLS integrated the bots into their existing compliance framework. The result was that compliance was not only maintained, but improved (as evidenced by fewer errors and consistent execution).

One could say TLS turned compliance into a beneficiary of RPA instead of a challenge, automation became a tool to enhance compliance, which is probably why the case study highlights passing cost savings to customers due to low-cost lending with no quality compromise​.

The solution here was alignment: making sure the compliance officer and IT security officer were part of the RPA project team, reviewing the design, and signing off that it met all requirements. With that, TLS avoided any regulatory issues (there were none reported) and in fact now has a strong story to tell regulators about how they ensure process adherence.