My Projects

Single-handedly architected, designed, developed, and deployed the entire full-stack SaaS platform within an intensive 3-month timeframe. Defined the complete technical vision and product roadmap, embedding data privacy and user consent mechanisms from inception, including full configuration of secure custom domain email infrastructure (Google Workspace, Netlify DNS for MX, SPF, DKIM, DMARC).

Engineered the platform for high availability and performance by selecting Supabase Pro (compute) and Netlify Pro plans, ensuring robust backend infrastructure and low-latency global hosting. Integrated Arcjet for essential rate limiting and bot protection.

Designed and implemented a comprehensive PostgreSQL schema using Drizzle ORM, meticulously modelling user roles, multi-stage vetting processes, consent timestamps, marketing preferences, detailed candidate profiles, secure file storage, referral tracking systems, and service order management.

Independently managed the entire application lifecycle: designing a complex PostgreSQL relational schema, building a high-performance asynchronous FastAPI backend, developing an interactive React/TypeScript frontend, and configuring cloud deployment on Heroku, ensuring GDPR compliance throughout.

Utilised SQLModel extensively for ORM functionality, defining intricate table relationships (e.g., User-Vehicle-Customer links, Bookings, Subscriptions) and ensuring data integrity through Pydantic-based validation across the backend.

Engineered a complete, custom user authentication and authorisation system from the ground up, featuring secure registration/login, JWT sessions, robust bcrypt password hashing, email-verified password recovery, and role-based feature access control tied to subscription tiers.

Played a central role in modularising the Opus UI framework by architecting, building, and publishing new, independent libraries within the @IntendaUK organisation, significantly enhancing maintainability and scalability.

Engineered custom Vite build configurations and meticulously managed complex package.json dependencies across the evolving library ecosystem, ensuring reliable build, packaging, and release processes.

Refactored and extended numerous existing Opus UI libraries to support the new modular architecture, ensuring seamless integration and compatibility, particularly with the Opus UI Language Server.

Architected and implemented the complete solution from the ground up using TypeScript, comprising a language server backend (implementing the Language Server Protocol with a modular design) and the corresponding VS Code extension client.

Implemented rich, context-aware LSP completion suggestions for Opus UI JSON definitions, covering components, properties, trait paths, script actions/triggers, flows, state references, and theme colours, directly integrated into the VS Code editor.

Developed LSP hover support, providing developers with instant access to detailed information for Opus UI symbols, including component property details, script information, and descriptions/types sourced directly from library definitions.

Architected, developed, and published the 'create-opus-ui-app' CLI tool using Node.js, owning the entire lifecycle from concept to public release on npm.

Designed and implemented an intuitive, interactive command-line interface (using Inquirer.js and Commander.js) to guide developers through project configuration via clear prompts and argument handling, reducing setup errors.

Engineered robust Node.js automation (utilising Degit for templating) to handle project template scaffolding, dependency installation, and dynamic configuration file generation based on user input, streamlining project initiation.

Provided ongoing technical leadership for the LegoZ platform, ensuring high availability and stability while architecting solutions for complex feature requests. Drove the evolution towards a more data-driven UI architecture and troubleshot intricate interactions between LegoZ and the core Opus UI engine.

Optimised key visualisation components (including the LegoZ Data Pedigree, Object Builder) for large-scale diagrams (thousands of nodes) using complex layout algorithms and advanced rendering strategies (e.g., dynamic relationships, collapsed node handling), achieving significant speed and responsiveness improvements.

Engineered specialised logic within the "LegoZ Union Builder" component to manage the creation, update, and visualisation of complex union field relationships, ensuring data integrity and architectural consistency within intricate data structures.

Architected and developed the entire "Maturity Assessment" platform from scratch using Opus UI. This enabled Deloitte to manage assessment frameworks, create/assign assessments, provide an interactive UI for capability evaluations (with file uploads), and integrate with Yellowfin for results visualisation.

Engineered and delivered the "Strategy Tracker" application using Opus UI, providing Deloitte's internal teams with a specialised tool to manage and track code exceptions within their wider platform ecosystem.

Architected and developed a bespoke Deloitte Component Library using Opus UI, providing a standardised set of reusable UI elements tailored to Deloitte's branding and functional requirements, utilised across both delivered applications.

Contributed to the design and development of the core engine that interprets JSON definitions and maps them to pre-built React components exported from libraries like `opus-ui-components`.

Participated in developing the state management and scoping system that facilitates flexible component communication through scripts and flows, simplifying complex interactions.

Designed and implemented several foundational React components for the `opus-ui-components` library, serving as the building blocks rendered from JSON definitions.

Collaborated on implementing the core transformation logic that translates Opus UI component PropSpecs (detailing types, defaults, etc.) into comprehensive JSON Schemas for validating the structure and types within a component's "prps" object.

Contributed to extending the schema generator to handle complex hierarchies, ensuring generated schemas could validate nested component definitions within "wgts" arrays and potentially recursive structures.

Contributed to optimising the schema generation process, improving its performance and efficiency for faster validation feedback within developer workflows, aiding early error detection.

Led the ground-up redevelopment of LegoZ using React and Opus UI, replacing its legacy Angular 4 architecture with a modern, declarative, JSON-driven system. This overhaul significantly enhanced maintainability, scalability, and performance by leveraging Opus UI's "components as data" paradigm.

Developed "opus-ui-legoz", a library of complex, LegoZ-specific React components (including the LegoZ Object Builder, Data Pedigree, Expression Builder). This enabled the Opus UI engine to render LegoZ-specific interfaces directly from JSON declarations for seamless workflow integration.

Extended the `opus-ui-legoz` library with custom JavaScript functions (callable as Opus UI script actions) implementing complex, LegoZ-specific functionality. This empowered declarative components with dynamic behaviours, streamlining workflow creation.

Architected and implemented the core drag-and-drop UI, featuring a dynamic component selection panel and sophisticated controls for managing layouts and component hierarchies.

Incorporated an interactive section using the core Opus UI engine to instantly render the dashboard from the current configuration state, providing immediate visual feedback during design.

Engineered context-aware editors displaying relevant configuration options (styling, content, bindings) based on selected components, ensuring a type-safe and intuitive editing experience.

Implemented an updated design theme across the Angular 4 platform, ensuring a modern and cohesive user interface consistent with Fraxses brand guidelines.

Merged FlowZ (my final-year university project) into the platform, extending its capabilities with advanced ETL workflow functionality and data pipeline management features, including its GoJS-based visual flow builder.

Leveraged GoJS to enhance key visualisation components (LegoZ FlowZ Builder, Object Builder, Data Pedigree), implementing custom node/link behaviours and optimising the rendering of complex data structures and relationships.

Applied the Fraxses design theme to the Apache Superset React frontend, ensuring visual consistency with the broader platform and enhancing the overall user experience.

Contributed to the ongoing development of the Superset integration by implementing custom features based on Fraxses' requirements and resolving identified bugs, improving overall platform stability and functionality within the Fraxses ecosystem.

Contributed to the platform's UI/UX redesign, focusing on modernising the aesthetic and enhancing overall usability of the AngularJS application through the use of Angular Material.

Diagnosed and addressed bugs across both frontend (AngularJS) and backend (C#) codebases, improving application stability and reliability.

Collaborated with the backend team to identify and resolve issues originating from C# interactions with stored procedures, mitigating bugs and unintended side effects.

Identified and resolved frontend bugs within the existing JavaScript and jQuery codebase, contributing to improved application stability and user experience for visual analysis tasks.

Implemented key frontend features, including a redesigned menu system and functionality for isolated chart rendering via URL parameters, enabling embedding within external applications.

Maintained existing D3.js charts and integrated additional functionality based on requirements, improving their utility for effective data analysis.

Developed an interactive Angular 4 interface with drag-and-drop functionality for visual ETL workflow construction. Implemented real-time input validation to ensure specification accuracy, enhancing data integrity.

Integrated GoJS to create custom, interactive ETL process visualisations, designing distinct node templates (sources, transforms, sinks) for clarity and intuitive flow representation.

Designed and built the core RESTful API (Node.js / Express.js) and MongoDB schemas to manage user accounts, ETL specifications, and workflow execution logic, with consideration for scalability.

Contributed to developing backend logic within the Spring MVC framework for course creation, update, and deletion functionalities used by instructors.

Developed responsive frontend views using JSP, providing the user interface for course browsing and enrolment.

Implemented database interactions using plain JDBC for managing user, course, and enrolment data within a MySQL database.