Software EngineerPalakkad, Kerala, India
Building production-ready software and the cloud infrastructure it runs on.
I have spent four years on the whole arc of a system — designing it, writing it, testing it, shipping it, and being the one who gets called when it misbehaves at two in the morning. Marketplace, logistics, fintech and commerce platforms, built with Node.js, Angular and React, running on AWS and Azure.
I am a software engineer with more than four years of professional experience building scalable web and mobile applications, backend systems, REST APIs and cloud-native solutions. My work covers the complete lifecycle — architecture and development through testing, CI/CD, cloud deployment, monitoring and production operations.
That range is deliberate. A backend engineer who has never been on call writes different code from one who has. Knowing how a service is deployed, what its logs look like at three in the morning, and how it degrades under load changes the decisions made months earlier, while the code is still being written.
The work has spanned marketplace, logistics, fintech and commerce platforms, built with Node.js and Express on the server, Angular, React and React Native on the client, and PostgreSQL, MongoDB and Redis behind them — deployed to AWS and Azure through Docker, Kubernetes and CI/CD pipelines, for clients in the United States and Qatar.
Application code, the service behind it, the infrastructure under that, and the pipeline that puts it all in production. I work across all four rather than handing off at the boundaries.
Web and mobile applications built on clean architecture, with the same care given to the component boundary as to the query plan behind it. The interface and the service are one system, and I work on both.
Services and APIs designed around how they will be changed, not only how they will be called. Clear boundaries, validation at the edge, predictable errors, and a data model that will still make sense a year from now.
Deploying and operating applications on AWS and Azure. Not only provisioning resources, but understanding what they cost, how they fail, and what happens to the running system when one of them goes away.
The path from a commit to a running process. Pipelines, containers, orchestration, and infrastructure defined in code so an environment can be rebuilt rather than remembered.
Local marketplace platform
A location-based marketplace connecting people with the sellers and services closest to them, serving over ten thousand users.
Read the case study
QR-based digital tipping platform
A digital tipping platform for hospitality staff: scan a QR code, tip the person who served you, no app and no cash.
Read the case study
Artisan marketplace platform
A marketplace giving independent artisans a route to sell handmade products online.
Logistics optimisation platform
Backend services for route optimisation and shipment management in a logistics operation.
Community commerce platform
A community commerce platform built around product discovery and everyday engagement.
Present
Amigosia
Kerala, India
Building and operating web and mobile products across marketplace, logistics, fintech and commerce domains — from the API and data model through to the containers and pipelines that put them in front of users in the United States and Qatar.
JavaScript and TypeScript day to day, C# where the platform calls for it, and SQL written by hand rather than generated.
Angular and React on the web, React Native on mobile, all built on semantic markup and a considered component layer.
Node.js and Express services, .NET where the stack is Microsoft, structured for change rather than only for launch.
Relational modelling in PostgreSQL, MySQL and SQL Server, document storage in MongoDB, and Redis in front of the hot paths.
Compute, storage and serverless workloads across four core services.
Application hosting, object storage and pipelines on the Microsoft stack.
The path from a commit to a running process — containerised, orchestrated, automated and observable.
Environments described in code so they can be reviewed, diffed and rebuilt instead of remembered.
The practices that keep a system workable long after the first release.
Agile delivery with clients across time zones, and the tooling that keeps a team honest.
Plenty of developers can get an application onto a server. Fewer have run one there through a bad deploy, a slow query under real traffic, or a dependency that failed at the worst possible moment. This is the part of the job I have spent the most time on.
01
Feature work, review, local verification
02
Branching model, pull requests, code review
03
Typed compilation, dependency locking
04
Unit, integration and smoke suites
05
Reproducible, minimal runtime images
06
Azure DevOps and GitHub Actions pipelines
07
Terraform-defined infrastructure on AWS and Azure
08
Kubernetes rollouts, reversible releases
09
Logs, metrics, alerting, incident response
Applications that stay readable and modifiable months after the first release.
APIs, services, database schemas and the business logic that sits between them.
Complete products, from the interface a user touches to the query that answers it.
Deploying and operating workloads on AWS and Azure, not just provisioning them.
Automating the route from source control through test and build into production.
Architectures sized for the load they will actually see, and for the team running them.
Getting an application working is the first quarter of the job. The rest is making it maintainable, observable, secure, and dependable at three in the morning when nobody is watching it.
Good architecture is rarely about adding another technology. It is about choosing the right few and keeping the whole system small enough that one engineer can hold it in their head.
Anything done by hand more than twice — testing, deployment, provisioning — is a future outage. Automation is less about speed than about removing the places where humans make mistakes.
Software engineering includes architecture, infrastructure, deployment, monitoring, performance, security, and the people who will be on call for whatever you ship.
11+
interns and junior developers mentored
Alongside product work I have mentored software engineering interns, focused on the practical side of the job that courses tend to skip — reading an unfamiliar codebase, debugging methodically, using Git in a team rather than alone, writing a pull request someone else can review, and understanding why a thing behaves differently in production than on a laptop.
Nehru Institute of Engineering and Technology
Coimbatore, Tamil Nadu, India
I came into software from aeronautical engineering. It turned out to be useful preparation: both disciplines are mostly about understanding a system well enough to predict how it fails.
Mechanical Design
Dassault Systèmes
Sustainable Design
Dassault Systèmes
Additive Manufacturing
Dassault Systèmes
The stack I use today will not be the stack I use in five years. These are the areas I am deliberately putting time into.
Consistency trade-offs, service boundaries, and architectures that survive real production load.
Better approaches to building and operating applications designed for the cloud rather than moved onto it.
Sharper CI/CD, Terraform-managed infrastructure, Kubernetes operations and the observability that makes them safe.
AI agents and AI-assisted engineering workflows, and where they genuinely reduce work rather than relocate it.
Get in touch
I am open to conversations about engineering roles, contract work and interesting problems — particularly where application development, infrastructure and reliability meet. The fastest way to reach me is email.
rajeevmohank@gmail.com