Nrishinghananda Roy

Shipping software is straightforward until the infrastructure becomes a bottleneck. Deployments that break production. Staging environments that drift from reality. Systems that fail on a Friday night with no clear path to recovery. These are not just engineering problems. They are expensive business problems.

I build and operate the infrastructure that stops these problems from reaching your users.

By implementing Infrastructure as Code with Terraform and orchestrating container workloads through Kubernetes, I ensure your environments are immutable, secure, and infinitely reproducible.

This means your team ships faster. I automate CI/CD pipelines using GitHub Actions and GitOps workflows via ArgoCD, making deployments predictable and rollbacks instant. It means a new engineer can spin up a working environment in minutes instead of days. It means your infrastructure scales autonomously when the business demands it.

I don't just string tools together. I write the custom automation that eliminates manual toil. I implement robust observability with Prometheus and Grafana so I never have to wait for an outage to tell me something is wrong. I document every system I build, and operate entirely asynchronously across time zones. You do not need to manage my day.

If your infrastructure is slowing your product cycle, or if you are building something that needs a scalable cloud foundation built correctly from the start, that is exactly what I solve.

A 15x performance improvement on a live system.

At Codefy GmbH in Germany, a third-party Java microservice was adding over 3 seconds of latency to every API request. I read through the codebase, understood exactly what it was doing, and rebuilt it from scratch in Rust (Axum) and PostgreSQL. Rresponse times dropped to under 200 milliseconds under production load.

The harder part was not writing the replacement. It was understanding an unfamiliar distributed system well enough to replicate its behavior correctly without breaking anything downstream.

A full cloud migration with production running throughout.

At Dhiway I provisioned and operated a globally distributed network of over 60 nodes on AWS using Terraform. When the decision came to migrate the entire infrastructure, I executed that migration while production stayed live the whole time. No incidents. No service disruption. No surprises.

Linux operations that kept an early platform running.

At Trustforum in France, I managed Linux servers for an early-stage community platform. User permissions, package management, system updates, and automated backups, and log rotation via Bash scripting. The kind of work that is only noticed when it stops happening.

Most companies discover a security problem after it has already caused damage. A compromised environment, stolen credentials, a breach that nobody noticed for weeks.

I think about security before the breach, not after.

In early 2026 I received what looked like a standard coding task from a recruiter. It was a carefully constructed attack, designed to execute silently inside a developer machine and extract credentials without triggering any visible warning. Rather than running it, I spent days pulling it apart stage by stage until I understood exactly how it worked, how it evaded detection, and what it was built to steal.

That experience sits underneath everything I build now. When I set up a deployment pipeline, I think about what an attacker would do with access to that pipeline. When I configure a container environment, I think about what happens if one workload is compromised and what it can reach from there. When I handle secrets, I think about every place those secrets could leak and close those paths before they become a problem.

Security built into infrastructure from the beginning costs almost nothing. Security retrofitted after an incident costs significantly more than that.

Rust Clippy

Clippy is the official Rust linter used across the entire Rust ecosystem. I contributed lints directly to the project, which required working through the compiler internals and the review process with the Rust team.

lsmdb

A persistent, crash-safe key-value storage engine built from scratch in Rust on an LSM-Tree architecture. Implements a Write-Ahead Log, Bloom Filters, LRU block cache, and a custom arena-allocated SkipList MemTable. Published on crates.io as a library and CLI binary.

I built this to understand how storage engines fail under pressure. That understanding directly informs how I reason about data tier architecture and I/O latency in production infrastructure.