Senior Software Engineer focused on Angular modernization, testing, and scalable enterprise delivery.

Senior Software Engineer

Modernizing Enterprise Frontends with Angular & Test Strategy

Senior software engineer with 10+ years of software development experience, including 7+ years specializing in Angular (7–21). Proven track record of modernizing enterprise applications, expanding test coverage, and improving long-term system reliability at scale.

225+ PRs160K+ Lines AddedAngular 7→21Vitest Adoption (Led Strategy)~2,000+ Unit Tests Improved1000+ Tests Added

Enterprise Angular Architecture & Scalability
Stabilized Angular 15 → 18 upgrade, resolving 50+ critical defects
Advanced Angular modernization from v18 → v21, reducing regression risk
Scaled Test Coverage Across ~3,000+ Tests, improving release confidence
Enabled a parallel Vitest + Karma testing strategy, increasing test performance and stability
Strengthened CI/CD pipelines and production reliability

Full Resume

Contact

Angular ModernizationLed large-scale Angular modernization efforts across enterprise applications, improving long-term maintainability, upgrade safety, and development velocity.

Cross-Version ExpertiseHands-on experience across Angular 7 → 21, navigating multiple framework evolution cycles

Upgrade Strategy ExecutionDelivered incremental upgrade approach to reduce risk and avoid large-scale regressions

Test Stability at ScaleMaintained reliability across ~3,000+ tests during framework transitions

Sustainable ArchitectureAligned components and patterns with modern Angular standards for long-term maintainability

Enterprise Application CoverageApplied modernization across multiple large-scale applications (VINELink & VINEWatch)

Testing ImpactImproved test reliability and release confidence across enterprise Angular applications through large-scale coverage expansion and testing modernization.

New Tests Added~33%

Tests Improved~61%

Vitest Tests Introduced142

Total Test Footprint Influenced~94%

Vitest Adoption & Testing Modernization

Introduced Vitest into both VINELink and VINEWatch to establish a scalable, modern testing path alongside legacy Karma/Jasmine suites. Defined the initial framework setup, patterns, and structure needed for long-term maintainability, while contributing 147+ new Vitest tests to accelerate adoption and future growth.

Added Vitest to both enterprise Angular repositories
Established reusable testing patterns and structure for long-term growth
Delivered 147+ new Vitest tests to seed adoption

Featured Case Studies

Selected Engineering Work

A few deeper examples of how I approach modernization, testing strategy, and enterprise frontend problem solving.

C#,Architecture,Gaming,TestingFeatured

Strengthening a C# Chess Rules Engine

Improved the game logic behind a C# chess application by separating board state, move generation, and legal-move validation into clearer, more dependable responsibilities.

TL;DR

Problem: Interdependent chess rules made move validation and board-state changes increasingly difficult to reason about
Solution: Reorganized the logic around explicit state, reusable move validation, and controlled move application
Impact: Improved correctness, debuggability, and the foundation for continued rules-engine development

C#Primary Language

Rules EngineCore Focus

State DrivenValidation Model

ExtensibleDesign Goal

Technical Leadership

Analyzed the rules engine as a state-management problem rather than treating each piece as an isolated collection of movement rules.
Separated move evaluation from move execution so a proposed move could be inspected before it changed the active board.
Reduced duplicated rule checks by moving shared validation into focused, reusable logic.

Outcome:Created a more predictable rules engine that is easier to test, debug, and extend as additional gameplay scenarios are introduced.

C#.NETGame LogicObject-Oriented DesignTesting

View Case Study

SaaS,Architecture,Angular,Full StackFeatured

Planning and Building a Specialized Multi-Tenant SaaS CMS

Planning and developing a multi-tenant SaaS content platform that will give small and medium-sized businesses in a specialized market a responsive, customizable web application without exposing the product's protected vertical concept.

TL;DR

Problem: A specialized SMB market needs responsive, configurable web applications without the cost and fragmentation of one-off development
Solution: Design a multi-tenant SaaS CMS with tenant isolation, role-based administration, reusable components, and configuration-driven presentation
Impact: Creates a scalable path from one focused implementation to a repeatable product while protecting the underlying market concept

Multi-Tenant SaaSDelivery Model

Role BasedAccess Model

CRUD + Soft DeleteContent Lifecycle

In DevelopmentCurrent Stage

Technical Leadership

Defined the product boundary between reusable platform capabilities and tenant-owned content and appearance configuration.
Planned a role model covering platform administration, tenant ownership, delegated content management, and public users.
Designed customization as structured configuration rather than customer-specific source-code branches.

Outcome:Established the product architecture, configurable presentation system, administrative boundaries, and phased delivery plan needed to evolve a focused prototype into a secure SaaS platform.

SaaSMulti-Tenant ArchitectureAngularCMSProduct Strategy

View Case Study

Gaming,ArchitectureFeatured

Extending a C# Chess Engine with King Safety and Material-Based AI

Extended a tutorial-based C# and WPF chess application with independently developed king-safety validation, castling rules, captured-piece tracking, and a computer-controlled opponent.

TL;DR

Problem: The guided implementation needed stronger rule enforcement and a playable single-player experience
Solution: Added board-copy simulation, king-safety filtering, castling validation, captured-piece tracking, and a material-scoring Black AI
Impact: Produced a clearer demonstration of C# architecture, game-state reasoning, and desktop UI integration

WPF DesktopApplication Type

.NET 8Runtime

Material BasedAI Evaluation

2Solution Projects

Technical Leadership

Kept chess rules in the ChessLogic project and presentation concerns in ChessUI rather than embedding engine behavior in event handlers.
Used copied board states to validate candidate moves without mutating the active game.
Designed the computer opponent to consume the same legal-move pipeline used by the human-facing game flow.

Outcome:Turned a guided implementation into a stronger portfolio project that demonstrates object-oriented game architecture, rule validation, board-state simulation, and asynchronous UI coordination.

C#.NET 8WPFGame LogicAIObject-Oriented Design

View Case Study

Angular,Frontend Architecture,State Management,GamingFeatured

Rummy.green Angular Game Engine Validation

Built a production Angular 21 frontend and reducer-driven game engine for a multiplayer Rummy platform before backend persistence existed, using AI opponents as a validation mechanism to continuously test and refine gameplay logic.

TL;DR

Problem: Complex game rules needed validation before backend infrastructure existed
Solution: Built a reducer-driven Angular game engine and introduced AI players to continuously exercise gameplay scenarios
Impact: Accelerated game engine development, uncovered edge cases early, and established a foundation for future multiplayer expansion

21Angular Version

3AI Opponents

2-4Supported Players

Reducer DrivenGame Engine

Technical Leadership

Designed the initial game architecture around a reducer-driven state management approach to keep gameplay logic predictable and testable.
Recognized early that manual testing would not scale as game complexity increased.
Introduced AI-controlled opponents as a development and validation tool rather than waiting for multiplayer functionality.

Outcome:Created a playable environment capable of exercising complex game rules, exposing edge cases, and validating game engine behavior long before multiplayer infrastructure and persistent storage were introduced.

AngularAIGamingTestingFrontend Architecture

View Case Study

Node.js,Fastify,Prisma,PostgreSQL,Backend ArchitectureFeatured

Building a Transaction-Safe Multiplayer Game Backend

Designed and implemented a transaction-safe multiplayer backend that mirrored the Angular game engine, enabling persistent game state, authenticated gameplay, API-driven actions, and multiplayer synchronization.

TL;DR

Problem: The frontend game engine needed to evolve into a persistent multiplayer platform while preserving gameplay integrity.
Solution: Built a Fastify + Prisma backend that mirrored the Angular game engine and validated every action through a centralized server-side rules engine.
Impact: Enabled authenticated multiplayer gameplay with persistent state, deck validation, and transaction-safe action processing.

FastifyBackend Framework

PostgreSQLDatabase

PrismaORM

2-4Supported Players

Technical Leadership

Designed the backend architecture from scratch around the existing Angular game engine.
Created a mirrored server-side game engine to ensure rule consistency between frontend and backend.
Identified deck integrity validation as a critical requirement for multiplayer reliability.

Outcome:Delivered a production backend capable of enforcing game rules, preserving deck integrity, synchronizing player state, and supporting future multiplayer expansion.

Node.jsFastifyPrismaAPI DevelopmentBackend Architecture

View Case Study

Angular,Node.js,Integration,Architecture,Full StackFeatured

Connecting a Frontend Prototype to a Production Multiplayer Platform

Connected an Angular multiplayer game platform to a newly developed Fastify backend by incrementally replacing client-side functionality with authenticated API-driven workflows while preserving gameplay continuity and maintaining production stability.

TL;DR

Problem: A frontend-only game engine needed to evolve into a production multiplayer platform without disrupting existing gameplay.
Solution: Incrementally replaced local functionality with authenticated API integrations while expanding backend capabilities.
Impact: Delivered a fully connected production platform with persistent state, administration tooling, and scalable architecture.

2Applications Integrated

FirebaseAuthentication Systems

Firestore → PostgreSQLPersistence Layers

Frontend + APIDeployment Targets

Technical Leadership

Defined an incremental integration strategy that minimized risk while connecting frontend and backend systems.
Identified opportunities to replace local functionality one API at a time rather than attempting a large-scale rewrite.
Designed API contracts that mirrored existing frontend game actions to simplify migration.

Outcome:Successfully transformed a frontend-first prototype into a full-stack production platform supporting authenticated users, persistent game state, multiplayer gameplay, administration features, and scalable backend services.

Node.jsFastifyPrismaAPI DevelopmentBackend Architecture

View Case Study

AngularFeatured

Angular 18 → 21 Upgrade Stabilization

Stabilized a multi-version Angular 18 → 21 upgrade under breaking framework changes, resolving systemic test instability and change detection issues without halting feature delivery.

TL;DR

Problem: Angular 21 introduced stricter change detection and broke ~260 tests
Solution: Identified systemic failure patterns and aligned code with new lifecycle behavior
Impact: Stabilized upgrade without halting development or introducing regressions

2Angular Applications Upgraded

3Angular Versions Traversed

~260Failing Tests Resolved

Technical Leadership

Owned end-to-end execution of Angular 18 → 21 upgrade across enterprise applications
Diagnosed systemic failure patterns instead of treating test failures as isolated issues
Identified how Angular 21’s stricter dev-mode change detection exposed lifecycle inconsistencies

Outcome:Delivered a stable Angular 21 upgrade by identifying and resolving systemic framework compatibility issues, enabling continued development without regression risk.

AngularUpgradeTestingChange Detection

View Case Study

C#,Gaming,ArchitectureFeatured

Building a Desktop Tetris Game with C# and WPF

Implemented a complete desktop Tetris experience in C# and WPF, combining object-oriented block modeling, collision-aware movement, line clearing, scoring, progressive speed, hold and preview systems, and a responsive keyboard-driven interface.

TL;DR

Problem: Real-time input, timed movement, collision rules, and rendering had to remain synchronized
Solution: Separated blocks, the game grid, queue, game state, and WPF presentation into focused classes
Impact: Delivered a playable desktop game with hold, preview, ghost-block, scoring, and progressive difficulty

WPFFramework

7Tetromino Types

10 × 22Board Size

.NET 8Target

Technical Leadership

Modeled all seven tetrominoes through a shared abstract Block type with specialized rotation data.
Kept authoritative gameplay rules inside GameState instead of embedding them in WPF event handlers.
Created a grid abstraction responsible for boundaries, occupied cells, completed rows, and row movement.

Outcome:Produced a playable Windows application that demonstrates C# domain modeling, real-time state management, asynchronous UI coordination, and separation between gameplay logic and rendering.

C#.NET 8WPFGame DevelopmentState Management

View Case Study

View All Case Studies