Suranjan Maity

Full-Stack Engineer ( .NET + Angular )

Crafted with architectural precision & a humane touch.

Handled production issues in systems serving 50k+ daily transactions. Focused on performance, system behavior, and production-grade reliability across the entire stack.

Reduced API latency from 45s to 1.2s under 50k daily traffic load.
Stabilized external API integrations to 99.9% uptime using Circuit Breakers.
Restored UI responsiveness spanning ~80% reduction in change detection cycles.
Review Selected Projects See Deep Dive
01
Selected Work

Production Proof Blocks

Latency bottleneck isolated & liquidated.

1. Computation Pipeline Bottleneck

Problem: API latency severely degraded to 45s (p99) under 50k transactions/day.
Fix: Pre-processed O(n) algorithmic pipeline using in-memory Hash Maps instead of relational joins.
Impact: Latency plummeted to 1.2s; DB thread starvation successfully eliminated.
View Architecture & Trade-offs
Root Cause:
  • O(n*m) unindexed nested loops blocking synchronous I/O operations inside the core .NET calculation engine.
Trade-off:
  • +400MB application memory footprint per instance required infrastructure scaling adjustments during peak hours.
Masking complexity from the consumer UI.

2. External Integration Fault Tolerance

Problem: Intermittent 3rd-party vendor outages were persistently locking consumer UI threads.
Fix: Implemented Circuit Breaker pattern wrapped with a Redis fallback cache.
Impact: SLA Uptime re-stabilized to 99.9% on consumer UI, entirely masking vendor volatility.
View Architecture & Trade-offs
Root Cause:
  • Tight runtime coupling with no timeout policies and the absolute absence of a reactive caching layer, creating a cascade failure.
Trade-off:
  • Accepted 5-minute eventual consistency; required coordinating with product managers to accept data staleness over UI unavailability.

3. Frontend Stability: Angular Reactivity

Problem: UI threads freezing heavily (massive frame drops) during data-grid renders containing 1,000+ rows.
Fix: Migrated from RxJS subscriptions to Angular Signals with strictly enforced `OnPush` strategy.
Impact: UI responsiveness restored rapidly via an ~80% reduction in unnecessary change detection tree processing.
View Architecture & Trade-offs
Root Cause:
  • Suboptimal `Zone.js` change-detection cycles triggered globally by unbounded, highly-active RxJS streams checking the entire application tree unnecessarily.
Trade-off:
  • Increased initial code verbosity for state management. Transitioning away from legacy declarative streams required a one-time intensive rewrite of complex template bindings.
02
Raw Evidence

Deep-Dive: Checkout API Deadlock Triage

When an enterprise checkout API experienced catastrophic blocking during a high-traffic window, it required immediate triage. This is the chronological resolution path isolating the bottleneck down to a background worker holding a strict table lock.

03:14 AM

API 500s Spiking (45s+ Latency)

Checked application APM. CPU/Memory were healthy across worker nodes. DB metrics showed rapid connection pool exhaustion.

03:19 AM

Isolated Deadlock SPID

Executed diagnostic script tracking `sys.dm_exec_requests`. Found SPID 142 locking the core `InventoryStock` table.

View SQL Session Telemetry Trace
Exclusive table lock found.
SELECT 
                                    r.session_id, status, command, blocking_session_id, wait_type, q.text AS FailedQuery
FROM sys.dm_exec_requests r
CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) q
WHERE r.blocking_session_id <> 0;

/* ----------------- RESULT ----------------- 
session_id: 142 (Background Worker)
status:     suspended 
command:    UPDATE 
wait_type:  LCK_M_X (Exclusive table lock acquired)
FailedQuery: 
    UPDATE InventoryStock 
    SET LastSync = GETUTCDATE(), StockCount = @sc 
    WHERE VendorId = @vid AND IsActive = 1; -- Triggered massive table scan
------------------------------------------ */
03:35 AM

Mitigation & C# Fix Deployed

Killed offending SPID. Deployed hotfix to replace blanket EF Core `.Update()` with an optimized `SqlBulkCopy` process batched into 1,000-row chunks to prevent lock escalation.

03
Engineering Ethos

How I Think

A senior engineer is defined by the practices they optimize for in a production environment.

Predictability over Cleverness

I do not merge "magic" code. I prioritize explicit data flow, strict typing, and readable architecture. Systems should be easy to onboard and trivial to maintain.

Measurable Improvements

"It feels faster" is not an engineering resolution. I trace bottlenecks, run profilers, and track real percentage deltas before considering a performance ticket resolved.

Debuggability over Abstraction

If a system fails at 3 AM, the error log must point exactly to the failing boundary. I engineer observability and strong logging directly into the architecture.

Production Tested

Core Toolkit

Backend Stability

  • .NET / C# / EF Core
  • REST API Architecture
  • SQL Server (Tuning & Profiling)
  • Redis (Distributed Caching)

Frontend Scale

  • Angular (Signals & Routing)
  • RxJS (Stream Management)
  • TypeScript (Strict Typing)
  • UI Performance Optimization

Observability & Ops

  • GitHub Actions (CI/CD)
  • Git (Branching & Releases)
  • xUnit (Deterministic Testing)
  • System Telemetry Tracing

Work With Me

I collaborate with engineering teams operating at scale - where performance, reliability, and system behavior directly impact users and business outcomes.

Engagement Focus

Strong fit for teams scaling .NET distributed systems or evolving complex Angular applications toward predictable, signal-driven architectures. I operate best in environments where production correctness, observability, and performance are treated as core engineering responsibilities - not afterthoughts.

If you're solving hard production problems and value measurable engineering outcomes, we should talk.

Start a Conversation
Suranjan Maity