Backend engineer building scalable, high-performance distributed systems
Focused on backend infrastructure, event-driven systems, and real-time data pipelines.

I build backend systems where scalability, consistency, and failure handling are critical requirements.

My work focuses on:

• Designing high-throughput event-driven systems (Kafka, async pipelines)
• Building idempotent, retry-safe workflows under distributed conditions
• Developing real-time data pipelines and streaming systems
• Ensuring system reliability, observability, and performance under load

• Systems must remain deterministic under retries and replays
• Execution must be consistent under concurrent input
• Failures must be observable, traceable, and recoverable
• External systems are treated as eventually consistent and unreliable

Low-latency order execution engine with deterministic matching

• Built price-time priority (FIFO) matching engine with support for partial fills and cancellations
• Designed order book (price-level architecture) enabling O(1) best bid/ask access
• Implemented deterministic execution using sequence IDs for replayability
• Developed real-time streaming (WebSockets) for order book and trade updates
• Achieved sub-millisecond processing latency in local benchmarks

Key Engineering Work

• Matching logic under concurrent order flow
• Low-latency system design and execution guarantees
• Real-time state propagation and consistency

→ https://github.com/samar-syd7/dex-matching-engine

Event-driven financial processing and risk evaluation

• Built Kafka-based ingestion pipelines for high-volume transaction streams
• Implemented risk scoring engine for anomaly detection and compliance workflows
• Designed audit logging architecture ensuring traceability across distributed systems

→ https://github.com/samar-syd7/crypto-transaction-monitoring-api

On-chain asset lifecycle with off-chain consistency guarantees

• Designed and deployed ERC-721 smart contracts
• Built backend services for asset lifecycle (mint → transfer → verify)
• Implemented event-driven synchronization using blockchain logs
• Handled on-chain/off-chain consistency under asynchronous execution

→ https://github.com/samar-syd7/asset-tokenization-platform

Incoming Orders
     ↓
Matching Engine (Price-Time Priority)
     ↓
Order Book Update
     ↓
Trade Execution
     ↓
Event Stream (WebSockets)
     ↓
Client State Sync

Event-Driven Architecture   | Kafka / Streams
Matching Engine Design      | Order Book + Execution Logic
Idempotent Processing       | Replay Safety
Concurrency Control         | Deterministic Execution
Real-Time Systems           | WebSockets / Streaming
Observability               | Metrics + Monitoring

Languages → Go · TypeScript · Python · Java  

Backend Systems → Node.js · Fastify · Django · Spring Boot  

Distributed Systems → Kafka · Redis · Event-driven architectures  

Data → PostgreSQL · Relational modeling  

Infrastructure → Docker · Containerized services · CI/CD  

Observability → Prometheus · Metrics-based monitoring  

Blockchain → Solidity · Ethereum · Web3.js  

• Building high-performance backend systems and real-time pipelines
• Designing event-driven architectures using Kafka and distributed systems patterns
• Developing low-latency execution and data processing systems
• Improving system reliability, observability, and scalability under load

• Open to backend / distributed systems roles
• Focus: Infrastructure · Platform · Trading Systems

Systems must remain deterministic, observable, and correct under failure.