Founding Senior Full Stack + AI Engineer | React, Next.js, Svelte, Node.js, TypeScript, LangChain

- 30% faster feature rollout by architecting a Svelte design system with reusable components, design tokens (color, typography, spacing), and Storybook documentation, adopted across teams in a 500+ person engineering organization.
- Built and deployed an internal RAG knowledge tool using LangChain, Hugging Face embeddings, and HyDE retrieval over design system docs, component APIs, and runbooks - evaluated with LangSmith and tuned chunking + embedding config.
- Shipped white-labeled pharmacy, telehealth, and diagnostics product surfaces in SvelteKit on a SOC 2 Type II certified platform, letting health systems and consumer health brands launch digital care under their own branding.
- Built runtime multi-tenant theming for those white-labeled surfaces, deriving each tenant's full token ramp from their brand colors at load time with contrast handled inside the derivation, so WCAG AA held for any brand without a per-tenant design pass.
- Enabled tenant self-service branding with Contentful, letting health systems edit their own public page content and set their brand colors from the CMS instead of routing every rebrand through engineering.
- 15% faster backend response achieved by designing and developing RESTful APIs using Node.js and SvelteKit.
- 20% faster page load times delivered by building server-side rendered and interactive Svelte features.
- 100% unit-test coverage with Vitest in CI/CD, gating merges on coverage and type checks.
- Integrated Claude into CI/CD as an automated PR reviewer with a rules.md ruleset (architecture boundaries, layering, naming, type-safety, accessibility, coverage) - the agent enforces it against each code change with inline file/line feedback, cutting reviewer turnaround.
- Managed auth and session flows using Firebase Auth with SvelteKit server-side logic, handling thousands of active sessions reliably across role-based access boundaries.

- 85% reduction in manual signing time delivered by developing a canvas-based document signing system supporting both digital and offline signature flows.
- Shipped feature modules on an entity-management platform trusted by 50,000+ companies and 200,000+ users across 70+ countries, extending core product functionality and streamlining corporate-governance workflows.
- Integrated third-party services including Xero, Stripe, and Adobe, plus SSO authentication and a public REST API, so client systems could plug into the platform directly.
- Automated compliance deadline tracking and document generation, replacing manual filing checklists with rule-driven reminders and templated document output for multi-jurisdictional entities.
- Built interactive organizational-chart visualization that renders complex multi-entity ownership structures, giving corporate service providers a single view of group hierarchies.
- Delivered KYC collection and corporate-onboarding workflows with staged data capture, document upload, and validation across jurisdictions.
- Built reporting and analytics dashboards in React and Ant Design, backed by Redux state modeling for large tabular datasets and filtered views.
- Modernized a legacy React codebase by converting class components to hooks with TypeScript, making previously untyped enterprise workflows safe to change.
- Built and maintained a shared component library with design tokens mapped from Figma styles to SCSS variables, ensuring visual consistency across the enterprise platform.
- Improved platform accessibility and compliance by implementing ARIA attributes, focus management, and keyboard navigation across core enterprise workflows.
- Eliminated recurring production bugs at the root cause instead of patching symptoms, tracing performance regressions through the stack on a platform enterprise clients ran daily compliance work on.

- 40% smaller payload size and faster requests achieved by migrating from REST to GraphQL.
- 30% lower latency in client-server fetching enabled by RTK Query with a custom GraphQL cache.
- Shortened onboarding time for internal users by about 35 % by partnering with non-technical teams to document and streamline workflows.
- Co-architected the full-stack system design alongside one backend developer, owning frontend architecture and contributing to API design, data modeling, and verification workflow orchestration for the VaaS platform.
- Built background-check, employment, and identity verification workflows end to end, from candidate intake through automated status transitions and result reporting.
- Designed and built the verification dashboard with real-time status tracking, API integration workflows, and programmatic verification pipelines serving SaaS platform consumers.
- Integrated Stripe billing and Plaid financial data, handling subscription management and secure third-party account linking within the verification pipeline.
- Enabled reliable real-time communication by developing solutions integrating with Pub/Sub and Kafka event brokers.
- Unified a fragmented interface by standardizing on TailwindCSS with customized Material UI components, giving the verification product one visual language across every workflow.
- Enhanced accessibility of verification workflows by applying semantic HTML structure, ARIA roles, and focus management patterns for screen reader compatibility.
- Owned projects end to end from architecture through deployment and testing, handing over documented systems the team could run without me.
- Kept sprints on schedule while levelling up the team, mentoring junior developers through code review and structured task breakdown.

- Shipped for 100+ clients overall, specializing in performance optimization, accessibility, and scalable UI architecture.
- Bootstrapped entire products end to end as founding developer - architecture, database schema, API layer, frontend, and deployment - including Housewell, a real estate platform with Next.js SSR, Prisma + PostgreSQL, WebSocket real-time collaboration, and electronic document signing.
- Built an AI co-pilot Chrome extension for freight dispatchers (Numeo Spot) running inside the DAT load board - AI-driven rate negotiation, instant RPM/margin math, broker verification, and ELD integrations with Samsara, Motive, and TT ELD.
- Built a cross-platform desktop finance app (Angelfish) in Electron with a local-first SQLite/TypeORM architecture, D3.js and Chart.js visualizations, and Plaid integration covering 11,000+ banks.
- Delivered real-time and event-driven backends with Node.js, Kafka, Twilio, and WhatsApp API for a creator-network growth platform (Megaphone) serving 500+ creators with 60M+ combined followers.
- Shipped multi-tenant SaaS platforms including Guardix (AI-powered guard scheduling with real-time GPS geofencing and incident reporting) and FeatureInbox (multi-source product feedback with roadmaps and public changelogs).
- Built bilingual, RTL-ready interfaces (LMIS, Libya's national labour-market platform) with Next.js, Ant Design, React Query, and i18next over a .NET/SQL Server backend.
- Shipped Web3 interfaces with Ethers.js, Web3Modal, WalletConnect, and IPFS for composable NFT minting and on-chain gallery flows (PunkBodies).
- Optimized extension runtime performance using Web Workers for location search, lazy-loaded routes, adaptive polling, and TTL-based caching with memory-capped registries, keeping a third-party-injected UI responsive.
- Made large datasets searchable in real time with AWS Elasticsearch indexing and faceted filtering, replacing slow relational table scans.

- 20% improved scalability and deployment efficiency achieved by designing full-stack architecture on Azure Cloud.
- Built the GHG emissions dashboard - a fuel-source donut breakdown, a Scope 1/2/3 split, and a category-over-time chart with dual axes and a previous-year overlay, all driven by From/To/Year range filters and topped with live KPI tiles for total emissions tracked, project cost, and projected benefits.
- Built the Climate Vulnerability Assessment module over FEMA, CDC, and HHS risk datasets - location search, a radial risk meter, an expected-annual-loss panel with social vulnerability and community resilience scoring, and 13 expandable natural-hazard cards (drought, hurricane, riverine flooding, wildfire, tornado, and more) each with loss estimates and national percentiles.
- Delivered the ESG Sustainability Assessment report - a 0-100 score gauge with rating bands, environment/social/governance risk sub-scores, a controversy-level meter, per-category scoring charts, and a benchmark table that auto-classifies each category into strengths or improvement areas.
- Automated CDP and GCoM regulatory report generation, replacing manual spreadsheet compilation with exports drawn straight from centralized municipal data.
- Made data access fast and type-safe by pairing Apollo GraphQL with Prisma ORM, eliminating hand-written query bugs across emissions and project datasets.
- Built the Action Plans project grid with per-column sorting and configuration across status, scope, sustainability type, budget, projected benefit, task count, location, and collaborators, plus create and row-level edit workflows for long-running municipal programs.
- Cut redundant network round-trips with Apollo Client caching and normalized query results, keeping chart-heavy dashboards responsive on large municipal datasets.

- Ensured healthcare data interoperability and FHIR compliance by collaborating with Google Developers to implement international data standards on a platform used by WHO, UNICEF, World Bank, USAID, and the Gates Foundation.
- Achieved about 98 % code coverage and ensured production reliability by writing and maintaining comprehensive unit and service tests in Jest.
- Delivered offline-capable field data collection aligned to the XLSForm standard, so health workers in low-connectivity areas could capture records and sync on reconnect.
- Built interactive geospatial views with Mapbox GL, rendering filtered field-collected health data over maps so program teams could spot coverage gaps by region.
- Implemented role-based access control and GDPR-compliant data handling across multi-tenant health programs, keeping sensitive records scoped to authorized teams.
- Set up the Lerna monorepo that let independently versioned OpenSRP packages ship together, removing cross-repo coordination overhead for distributed contributors.
- Built the shared Ant Design component layer used across every OpenSRP module, so new health programs shipped by composing existing pieces instead of rebuilding them.
- Made complex multi-store state predictable with a Flux architecture, turning intermittent state bugs in health-record workflows into traceable ones.
- Ensured accessibility compliance for healthcare interfaces by implementing WCAG-compliant markup and testing with screen readers to support diverse user needs.
- Held the release bar on open-source health software with peer review, CI/CD pipelines, and automated test gates blocking every merge that regressed.
- Cut duplicated code across a growing open-source codebase with shared utilities and modular components, holding contribution velocity steady as the project scaled.

- Delivered high-priority projects within 2-3 week deadlines while maintaining strict performance and quality standards.
- Hit pixel-perfect fidelity on client Figma mockups, translating designs into production React components that matched the source file across breakpoints.
- Enforced TypeScript strict mode across the codebase alongside thorough code review and unit tests, catching whole classes of runtime errors before release.
- Reorganized an unstructured codebase into clean modules, making an inherited project maintainable enough to ship features on deadline.
- Made hand-off painless by standardizing component patterns and documenting them so the client's own team could extend the work unaided.
- Delivered on schedule across a cross-functional team of designers, QA engineers, and project managers, with documentation clear enough to survive hand-off.

- Built monitoring and device-status interfaces for telecom hardware replacing legacy landline (POTS) service across fire and security alarms, elevators, and enterprise analog systems.
- Turned a tangled legacy UI into reusable React modules, making a telecom codebase safe to extend rather than risky to touch.
- Turned rough mockups into shipped, responsive interfaces with ReactStrap, closing the concept-to-production gap without a design system to lean on.
- Connected the business and application layers so data moved reliably between backend services and the interfaces operators worked in.
- Shipped interfaces that held up everywhere by testing across browsers and devices and resolving layout inconsistencies before they reached users.
- Kept an outsourced codebase reviewable with disciplined Git history and structured code review, so the client team could pick it up cleanly at hand-off.
- Shaped the product rather than just building the spec, feeding continuous design and usability feedback back to stakeholders mid-build.

- Delivered 3+ client projects in parallel with 100 % on-time completion, maintaining quality standards under high-pressure timelines.
- Reduced maintenance issues by about 25 % by standardizing frontend architecture and enforcing scalable coding practices across projects.
- Improved onboarding and task turnaround efficiency by about 30 % through mentoring and supervising 3 junior developers and interns.
- Maintained zero critical defects post-release by taking full ownership of core modules and ensuring proactive testing and QA coverage.
- Owned frontend architecture decisions across concurrent client codebases, choosing state management, routing, and folder conventions that new developers could pick up without a rewrite.
- Enhanced code modularity and scalability by decoupling and refactoring legacy UI into reusable React components.
- Integrated third-party REST APIs and authentication providers into client applications, handling error states, retries, and token lifecycles so failures stayed invisible to end users.
- Translated client requirements into scoped technical plans and estimates, breaking vague briefs into deliverables the team could commit to within fixed timelines.

- 90%+ customer satisfaction maintained while handling 40-50 support tickets daily via Zendesk for an earned-wage-access fintech integrated with 300+ payroll systems including ADP, Paychex, Workday, and UKG.
- Caught outages before users reported them by proactively monitoring systems and escalating to Tier 2 and Tier 3 with the diagnostic detail needed to act immediately.
- Turned support patterns into product feedback, surfacing recurring pain points and proposing workflow fixes that removed the source of the tickets.
- Built the escalation path the team ran on, cutting time-to-owner on critical requests.
- Kept users on the product through payroll-critical issues, resolving technical concerns fast and pulling in engineering when the fix sat outside support's hands.
- Cut repeat resolution time by writing the process documentation and incident reports the team reused instead of re-diagnosing known issues from scratch.
- Made every incident traceable with complete case documentation and consistent follow-up, so nothing dropped between shift handovers.

Bachelor in Computer Science.