From Intern to Sr. Staff Engineer: 20 Years of Building at Scale

Twenty years ago, I walked into HCL's Noida office as a software intern with a head full of textbook Java and zero intuition for production systems. Today, I'm a Sr. Staff Software Engineer at ServiceNow, designing Agentic AI workflows that aim to compress six-week platform upgrades into hours. The path between these two points wasn't linear — it was a series of bets on technologies, teams, and problems that seemed just slightly too hard at the time.

The Early Days: Learning to Ship (2006–2009)

At HCL, I built a bug-tracking tool for our project. It wasn't elegant — Struts, MySQL, a healthy dose of copy-pasted XML configurations — but was able to present in my first industry demo and get feedback. That experience planted a seed: the best engineering isn't about the most sophisticated code, it's about solving a real problem fast enough that the solution matters.

I moved to OpenText, where I worked on a Java/XForms development platform that was designed to fast pace deliveries of integrated UIs and web services. This was my first encounter with the idea that tooling is leverage — a well-built platform multiplies every developer who touches it.

At RBS, I cut my teeth on enterprise-scale systems, reverse-engineering a Visual Basic BI product into a modern GWT + Hibernate + JPA stack. The lesson here was about migrations: legacy systems aren't bad systems, they're systems with gravity. You respect the gravity, or the migration fails.

The Scale-Up: Big Data and Real-Time Systems (2010–2015)

Joining Publicis Sapient pushed me into the deep end of distributed computing and high througput systems. I was processing 16 million financial records in 2 hours using Java for wealth managers and analyst. I led teams across the US and India, solving problems on the UBS trading floor where latency wasn't just a metric — it was money.

This period taught me that distributed systems are fundamentally about trade-offs. CAP theorem isn't academic when your Kafka consumer is lagging and traders are waiting. You learn to think in failure modes: what breaks first, what's the blast radius, how do you recover.

Then came my second stint at RBS (NatWest), where I was architecting an omnichannel banking platform serving 20 million+ users across mobile, web, and ATM channels. This was microservices before microservices were cool — Spring Boot, Docker, Kafka, real-time event processing. We built a Twitter sentiment analysis engine using LingPipe ML to transform customer feedback into actionable intelligence.

The key insight from this period: scale isn't just about handling load, it's about building systems that multiple teams can evolve independently. Conway's Law is the most important law in software architecture.

The Cloud-Native Transformation and the AI Rush(2016–2025)

My nearly decade at Oracle was where everything came together. I shipped products that touched every layer of the modern stack:

• Verrazzano — An enterprise-grade container-native platform on Kubernetes with Prometheus, Grafana, and Istio integration. I led the effort that won adoption by a major Japanese enterprise customer. This taught me that open-source credibility and enterprise reliability aren't opposites — they're complements.
• RAG-Powered LLM Platform — Built with Streamlit, LangChain, Ollama, and Oracle Database. This was my first serious production AI system, and it taught me that the hard part of AI isn't the model — it's the data pipeline, the evaluation framework, and the feedback loop.

Through Oracle, I worked across Java, TypeScript, Go, and Python daily. I became a strong believer in polyglot engineering — the right language for the right problem. Go for infrastructure tooling. Python for ML pipelines. TypeScript for anything touching a browser. Java for enterprise services where the ecosystem is unmatched.

I also learned Kubernetes can solve most of your problems, if not yet, then soon will !

The AI Platform Chapter (2025–Present)

At ServiceNow, I'm driving the design of Agentic AI workflows — autonomous systems that can reason about platform state, plan upgrade sequences, and execute changes with minimal human intervention. It's one of the most intellectually stimulating work of my career.

What I've learned about AI in production: the technology is genuinely transformative, but the gap between a demo and a system that enterprise customers trust with their critical workflows is enormous. You need observability, rollback mechanisms, human-in-the-loop checkpoints, and rigorous evaluation. You need to earn trust incrementally.

Patterns That Survived 20 Years

Looking back across HCL, OpenText, Amdocs, RBS, Publicis Sapient, Oracle, and ServiceNow, a few patterns have remained constant:

1. Tooling is the highest-leverage work you can do. A platform that makes 100 developers 10% more productive is worth more than any single feature you could build.
2. The best architecture is the one that lets teams move independently. Whether it's microservices, module boundaries, or API contracts — organizational autonomy drives velocity.
3. Production teaches you things no design document can. Every real outage, every unexpected failure mode, every midnight page — they build an intuition that compounds over decades.
4. Technology changes, but trade-offs don't. Consistency vs. availability. Simplicity vs. flexibility. Speed vs. correctness. The specific technologies rotate, but the decision frameworks are permanent.
5. People scale better than systems. The best thing you can do for a codebase is invest in the people who maintain it. Code reviews, mentorship, clear documentation — these are infrastructure too.

If you're early in your career: pick problems that scare you slightly, join teams that ship, and optimize for learning rate over title. The compound interest on skills acquired in your first decade is extraordinary.

If you're mid-career: start building your point of view. The industry doesn't need more people who can implement a spec. It needs engineers who can look at a problem space and say "here's how I'd architect this, and here's why." That perspective is what separates a senior engineer from a staff engineer.

And if you're a fellow staff+ engineer: remember that our job isn't just to build systems. It's to build the environment where great systems can emerge. That means culture, incentives, technical strategy, and hiring — not just code.

Here's to the next twenty years and beyond.