Overview
CanCap Group is a Canadian financial services company operating in the automotive finance space.
I worked on an internal platform that streamlines a document-heavy review workflow. The system ingests submissions, uses AI-assisted document extraction to read supporting documents, and applies validation rules to identify missing or inconsistent information. Instead of manually reviewing every document from start to finish, analysts can focus on flagged items and exceptions, turning a paperwork-heavy manual process into a focused, exception-driven workflow.
My Role
As a Senior Software Engineer, I primarily own the frontend of the application and act as the subject matter expert in that area. I also contribute to backend APIs, validation logic, and system reliability improvements. My work spans feature development, refactoring, debugging, and reliability improvements, with a strong focus on improving maintainability, developer experience, and real-world usability for operations teams.
Challenge
The platform grew from an early MVP into a production system — bringing with it the classic tension between shipping new features and continuing to strengthen the foundation beneath them. It operates in a real business workflow where reliability matters. Analysts depend on the application to work through their review queue efficiently, while operations managers need visibility into activity, validation rules, and workflow performance.
At the same time, the system has to handle messy real-world data. Submitted documents do not always contain clean, predictable values, which means validation logic has to be precise enough to catch real issues without falsely rejecting valid records.
Technical Focus
My work focused on making the platform more reliable, maintainable, and useful for daily operations. On the frontend, I improved application stability by implementing a layered error-handling approach that prevents individual failures from affecting the entire interface. Instead of users seeing a blank screen when certain backend errors occur, the application can now recover more gracefully and provide a more controlled experience.
I also worked on improving frontend structure and standards. This included refactoring earlier pages, tightening React patterns, improving consistency across components, and documenting frontend conventions through a style guide so future work follows clearer expectations.
On the backend and validation side, I contributed to API endpoints and validation logic used by the application. A major focus was making validation behavior better reflect real-world input. This included handling variations in document values, normalizing inconsistent data formats, and reducing false failures caused by human-entered or system-generated differences.
A recurring theme across the work was turning manual or repetitive processes into more reliable, maintainable workflows. Rather than treating each issue as an isolated fix, the goal was to improve the underlying patterns so the system became easier to reason about, extend, and support over time.
Platform Concepts
a closer look at the platform
A visual overview of the validation workflows and operational tooling developed for the platform.
Visuals are representative recreations designed to protect internal data and proprietary workflows.
Key Contributions
The following contributions each addressed a specific gap in reliability, visibility, or operational clarity, that had a direct impact on how the platform was used day to day.
Validation Center
Operations needed a reliable way to verify what each validation rule checks and when it is triggered, ensuring it aligns with agreed-upon requirements.
A static document would have created a long-term maintenance challenge, because validation rules change over time and separate documentation can drift out of date. Instead, I delivered a manager-facing Validation Center that reads from the live validation configuration and presents the rules through the application.
This made the system itself the source of truth. Managers can search, filter, review, and export validation rule information without relying on engineers to maintain separate documentation. The result was a self-service tool that reduced manual explanation work, improved transparency for operations, and removed an ongoing documentation-maintenance burden.
Frontend Error Handling
Certain backend failures previously affected the broader application experience, interrupting analysts mid-workflow.
I introduced a layered use of React error boundaries across the application, placing them at app, route, and component levels to isolate failures and prevent them from propagating through the entire UI. This allowed errors to be contained closer to where they occur, improving stability without affecting business logic.
Like most resilience work, it is invisible when functioning correctly, but it had a direct impact on user trust: analysts could work with confidence that an isolated issue would not interrupt their entire session.
Validation Logic Improvements
The validation system needed to handle messy real-world data more intelligently.
I improved validation behavior by introducing more tolerant matching and normalization patterns for cases where valid data appeared in different formats, abbreviations, or naming variations. This helped reduce false failures without making the rules overly permissive. These improvements made the platform behave more like a mature production system, with validation logic better aligned with how data actually appears in real workflows.
Operational Tooling
I built tools that gave operations and management better visibility into how the application was being used.
This included work on activity tracking, audit visibility, filtering, export functionality, and analytics-related improvements. These tools gave managers direct visibility into team workflows and system usage, connecting engineering output to real operational needs.
Outcome
My contributions helped improve the platform across several dimensions:
- frontend errors contained and recoverable rather than affecting the whole application
- documented component standards that reduced onboarding friction
- validation logic that handles real-world data variation without false rejections
- operational dashboards giving managers self-service visibility into workflows
- validation rules surfaced through the application, keeping documentation current
Together, these changes helped the platform mature from an early foundation into a more stable and maintainable production application.
Reflection
Working on this platform strengthened my ability to think beyond individual screens and understand how systems behave end to end. It pushed me to reason through frontend behavior, backend responses, validation rules, data quality, and operational workflows as connected parts of the same product experience.
It also made me a stronger product-minded engineer. The goal is not only to write code that passes review, but to build solutions that support real workflows, reduce friction for users, and leave the system easier to maintain than you found it.