Piyash Khanal
Building scalable systems, distributed architectures, and high-performance applications.
01 — About
About me
I'm a software engineer focused on backend and distributed systems, building reliable services that hold up under real-world load. My core stack is C# / .NET, where I design microservices with Clean Architecture and CQRS, coordinate workflows with the Saga pattern over RabbitMQ, and persist state in PostgreSQL.
I care about the parts of engineering that don't show up in screenshots: clear service boundaries, observable systems, and performance you can measure rather than guess at. I've shipped real-time features over WebSockets, optimized hot API and database paths, and packaged shared logic into internal NuGet libraries.
Before specializing in backend systems I built mobile and web products with Flutter and React, which still shapes how I think about the contract between a clean API and the people consuming it.
Key strengths
- Distributed systems & microservices
- Clean Architecture & CQRS
- Event-driven messaging (RabbitMQ)
- Performance & database optimization
- Real-time systems (WebSockets)
- Cloud deployment (AWS)
02 — Experience
Where I've worked
A year of shipping
~1782 contributions
Innovate Tech
Software Engineer
2024 — PresentDesigning and building microservices for a large-scale educational platform.
- Architected microservices for an educational platform using Clean Architecture and CQRS, keeping service boundaries clear and independently deployable.
- Implemented the Saga pattern over RabbitMQ to coordinate distributed transactions reliably across services.
- Built real-time features over WebSockets for live updates and notifications.
- Modeled domain data in PostgreSQL with an eye on query performance and consistency.
Associate Software Engineer
2023 — 2024Focused on API and database performance, plus shared internal tooling.
- Optimized hot API endpoints, cutting response times on key paths.
- Tuned database queries and indexes to reduce load and improve throughput.
- Authored reusable internal NuGet packages to standardize logic across services.
- Ran load tests to validate performance under expected and peak traffic.
Trainee Software Engineer
2023Built fundamentals in the .NET ecosystem while shipping fixes to production.
- Resolved bugs across the codebase and shipped fixes to production.
- Optimized EF Core queries to remove N+1 patterns and reduce database round-trips.
Shades and Shadows Media Technologies
Mobile & Frontend Developer
2022 — 2023Delivered cross-platform mobile apps and responsive web frontends for clients.
- Built cross-platform mobile applications in Flutter from design to release.
- Developed responsive, accessible websites in React.
- Worked directly with clients to translate requirements into shipped features.
03 — Skills
Tools I work with
Languages
Architecture
Backend
Databases
Messaging
Cloud
DevOps
Tools
04 — Projects
Featured projects
LifeKit
Blood Donation Platform- Problem
- Connecting blood donors with recipients in time is hard — requests are urgent, donor availability changes constantly, and coordination usually happens over scattered phone calls.
- Solution
- A platform that matches donors to nearby requests by blood type and location, and pushes real-time notifications the moment a compatible request appears, so the right donor hears about it fast.
- Architecture
- Flutter mobile client talking to a .NET REST API, with PostgreSQL for persistence and a notification pipeline for real-time alerts to matched donors.
Event Management System
Ticketing & Attendance- Problem
- Manual event check-in is slow and error-prone, and organizers rarely get clean attendance data afterward.
- Solution
- A system with QR-based ticket validation for fast, reliable entry, live attendance tracking, and reporting that gives organizers a clear picture of turnout.
- Architecture
- Backend service issuing and validating QR-encoded tickets, recording attendance events, and aggregating them into reports.
05 — Case Studies
Engineering deep-dives
Coordinating Distributed Transactions with the Saga Pattern
Challenge
An enrollment flow on the educational platform spanned several microservices — payments, course access, and notifications. A naive distributed transaction risked partial failures leaving users charged without access.
Architecture decisions
- Adopted the Saga pattern with RabbitMQ instead of a distributed two-phase commit.
- Modeled each step as an event with an explicit compensating action.
- Made handlers idempotent so retries never double-apply effects.
Technical tradeoffs
Sagas trade strong consistency for eventual consistency and add orchestration complexity, but avoid the fragility and coupling of distributed locks across services.
Scaling considerations
Because steps are message-driven, each service scales independently and absorbs spikes through the queue rather than backpressuring callers.
Outcome
Enrollment became reliable under failure — incomplete flows automatically compensate and resolve to a consistent state.
Cutting API Latency Through Query and Caching Work
Challenge
Several read-heavy endpoints were slow under load, driven by N+1 queries and repeated computation of rarely-changing data.
Architecture decisions
- Profiled real traffic to find the actual hot paths before changing code.
- Eliminated N+1 patterns in EF Core and added targeted indexes in PostgreSQL.
- Introduced Redis caching for stable, frequently-read data.
Technical tradeoffs
Caching adds invalidation complexity, so it was applied only where staleness was acceptable and the read/write ratio justified it.
Scaling considerations
Lower per-request cost and fewer database round-trips raised the traffic ceiling the same hardware could handle.
Outcome
Key endpoints saw roughly a 40% latency reduction, with database load meaningfully down.
06 — Philosophy
How I think about engineering
Build for maintainability
Code is read far more than it's written. Clear boundaries and honest naming beat cleverness.
Prefer simplicity over complexity
Reach for the simplest design that solves the problem. Add complexity only when the problem demands it.
Measure before optimizing
Profile the real hot paths first. Guessing at performance wastes effort and hides the actual bottleneck.
Design for scalability
Favor stateless services and message-driven workflows so the system grows by adding capacity, not rewrites.
Automate repetitive tasks
If it's done by hand twice, it's worth scripting. Automation removes toil and a class of human error.
Focus on reliability
Idempotency, observability, and graceful failure matter more than the happy path. Systems should fail safe.
07 — Resume
Interactive CV
Professional summary
I'm a software engineer focused on backend and distributed systems, building reliable services that hold up under real-world load. My core stack is C# / .NET, where I design microservices with Clean Architecture and CQRS, coordinate workflows with the Saga pattern over RabbitMQ, and persist state in PostgreSQL.
08 — Contact
Let's build something
Open to backend and distributed-systems work. The fastest way to reach me is email — or connect on LinkedIn and GitHub.