20 Years on Reflextions ...
This might read a bit like a resume, as I am not really a natural writer and tend to jump straight to the facts in chronological order. Really, this is just a reflection of my career in tech so far. I am incredibly grateful to my colleagues - from my very first manager to the product manager I disagreed with (and regretted days later). Everyone taught me something, even the intern who had a clarity of thought like nobody else on the team. I am also immensely proud of the organizations I managed to be a part of, and the culture and system maturity built over decades by their veterans. Please feel free to comment and remind me of anything that has stayed with you from our interactions. (If it is something negative, you can DM me to resolve it and make peace! :))
Twenty years ago today, I embarked on my very first job straight out of college. Coming from a computer science background, I had a solid understanding of programming and building small-scale software, thanks to various mini and major projects. These included reservation systems and designing and administering my college website—for which I used a telnet terminal and an ERNET FTP server to upload content. However, the technology used in real-world production systems was completely different from what I had practiced.
As an eager 21-year-old arriving in Chennai, it was decided (likely at random) that I would be trained on Oracle Apps and assigned to a project. Since it was a service-based company, these were client-facing projects. Although university had taught me SQL and Oracle databases, I had no idea how to build software with them without a programming language like Java. Following training—which I topped by the narrowest of margins—my work revolved primarily around Oracle Forms, which allowed users to input and save data into an Oracle database, and Reports, which formatted and displayed that data on the screen. All of this was part of Oracle Apps, an Enterprise Resource Planning (ERP) system, similar to SAP.
After nearly a year, I relocated to Hyderabad to join a very small company—what we would call a bootstrapped startup today—focused on financial technology. My role involved downloading stock exchange data using Bloomberg’s C API and storing it in a PostgreSQL database. We built web portals to analyze and present this data, and even performed “what-if” analyses on stock and option data. Much of our prototyping started in Microsoft Excel with VBA scripting before being migrated to a production stack of PHP, Apache, and PostgreSQL on Linux servers. We used PostgreSQL instead of MySQL because it was closer to Oracle, free, and, unlike MySQL at the time, fully supported views.
One of the most interesting aspects of that role was developing stock charts and a custom chat application. Because JavaScript libraries weren’t mature enough yet to build native stock charts like Open-High-Low-Close (OHLC) charts, we adopted Adobe Flex. Flex was a rising technology for building Rich Internet Applications (RIAs), powered by ActionScript (the language behind Adobe Flash) and MXML, a declarative markup language used to define the user interface. Since it was licensed software, we initially explored an open-source alternative called OpenLaszlo, but we eventually abandoned it due to lack of maturity and stuck with Adobe. The beauty of Adobe Flex and Adobe AIR was their ability to compile into standalone desktop executables for Windows and other platforms. Our primary limitation was file I/O, as it was originally built for browsers and could only write to a specific directory called “fscommand”. We also experimented with Visual Basic, which offered better performance and did not require the Flash runtime.
For the chat application, PHP turned out to be our best option. While PHP had a reputation for being fragile, we utilized it in a strongly-typed, object-oriented manner. This was back in 2007, and we drew heavy inspiration from Skype, which we relied on for international voice calls and group chats. We tailored our chat system specifically for the financial domain. Looking back, this startup environment is where I experienced the fastest professional growth of my entire career.
My next move was to a technology giant, which gave me my first look at the culture of a major product organization. The scale was massive, featuring an array of in-house tooling including proprietary email, conferencing, and build systems. It was an exceptional place to work and profoundly shaped my career. I spent over five years there across multiple teams, largely continuing the Oracle application work from my first job—but this time, building it as a vendor. It was a remarkable period; we were delivering rich, browser-based applications where updating data without refreshing the page (partial page rendering) was still a major feat. Although Ajax had been adopted by Gmail three years prior, it had not yet taken hold in the enterprise space. Oracle used a lightweight JRE called JInitiator, which downloaded to the desktop on first access and launched Java applets directly from the browser. While Forms and Reports handled transactional workflows, background tasks were powered by concurrent programs running PL/SQL or shell scripts.
The domain at this point was Supply Chain, where terms like Purchase Order, Sales Order, and Consigned Inventory were predominant. The mobile version of the application ran on handheld devices with a DOS prompt connecting to a telnet server powered by Java. It is worth remembering that the iPhone had not even been born yet.
This was where I met people who went on to build truly remarkable things. In my view, Oracle served as a vital stepping stone and career accelerator for many entry-level engineers. We managed to navigate the 2008 financial crisis together, forging incredible connections that remain strong to this day.
At that time, social media in India was predominantly Orkut, though by 2008, Facebook and Twitter began grabbing major market share. Yahoo Messenger was also soon replaced by Google Talk, which was lightweight and embedded right inside Gmail.
Sometime around 2010, I became fascinated by web services and began building them inside Oracle. While Oracle already had SOA, which prominently relied on SOAP (and all the WSDL complexity), the simplicity of REST captured my interest. Around the same time, Sun Microsystems was acquired by Oracle, making Java a central focus of innovation with new technologies like JavaFX, GlassFish, and NetBeans.
With the introduction of Google App Engine, I developed a strong interest in Platform as a Service (PaaS) and started using it for my personal projects. Back in 2009, it only supported Python, but once Java support was added, I decided to take a gamble and change my domain altogether.
This transition welcomed me into the world of gaming, which was culturally very different. For the first time, I was collaborating with an incredibly diverse group of people, including designers, artists, and product managers. Even the engineers working on the game clients were highly specialized, possessing deep knowledge of game engines and physics. Working at Electronic Arts (EA) was an incredibly fast-paced experience, both in terms of technology and people. Within months, your project could change, features could be shut down, or you might find yourself working with team members from a completely different region of the globe. One of the greatest lessons I learned there was how to be truly agile—sometimes you only found out the day’s top priority that morning. I also traveled extensively to other studios during this time, which gave me firsthand insight into the work culture and discipline of other parts of the world, especially the USA and Canada.
One of my notable projects at EA was working on the World Series of Poker, which introduced me to the functional programming paradigm of Erlang and Elixir. It completely changed how I thought about procedures and variables. Another project was Monopoly Bingo, which squeezed out every bit of potential from the then-limited Google App Engine. Because Datastore was our only persistence layer (which was NoSQL), our architecture had to be designed around key-based access rather than traditional SQL filters. Since writing to storage was expensive but compute was cheap and horizontally scalable, we leveraged techniques like sequential random number generators instead of storing every state. We jokingly called this “cost-oriented programming” 🙂.
It was a project of many firsts in my career: we used Gatling for load testing, Swrve for A/B testing, PagerDuty for alerting, and TestNG for unit tests. We even utilized Incredibuild to harness the idle power of everyone’s desktop machines to accelerate our build system. Later, I worked on titles like Tetris Blitz and Bejeweled Blitz, which used a LAMP stack. This was my first time using AWS as the main cloud provider, giving me a chance to brush up on PHP, which I hadn’t touched in years. Similar to Google’s Datastore, we used Couchbase for NoSQL, which eventually transitioned to DynamoDB in the Amazon ecosystem, while ElastiCache served as our equivalent to App Engine’s Memcache. Since Kubernetes didn’t exist yet, everything ran on individual VMs behind a load balancer.
Later, I moved to JDA, which was completely a Google shop. By then, Google Cloud Platform offered a rich suite of services, including BigQuery, Dataflow, Cloud Storage, Cloud SQL, and Pub/Sub. We used BigQuery and Dataflow to handle high-scale data ingestion and validation, while Pub/Sub enabled us to scale out, ultimately saving master data in Cloud SQL to service the Angular-facing APIs. Principles like Single Source of Truth (SSOT), Infrastructure as Code (IaC), Keep It Simple, Stupid (KISS), and “You Aren’t Gonna Need It” (YAGNI) became our daily buzzwords. Ultimately, this role provided a huge learning curve on how to operate in a modern cloud environment, designing multiple microservices that interacted not just through synchronous REST calls, but also via Pub/Sub push and pull subscriptions.
My next major milestone was at Salesforce, where we built the Loyalty System from the ground up on their highly mature and adaptable platform. It was incredible to experience how much out-of-the-box functionality was available with minimal custom code—a testament to a platform versatile enough to support virtually any business domain. Indeed, with Apex on the backend and LWC on the frontend, one can construct robust applications in hours without worrying about database management, web servers, or API routing. This role served as a masterclass in maximizing the utility of reusable shared components across various teams and organizational units, while also bringing valuable exposure to GitOps, service-to-service communication configurations, and IAM roles.
Currently, I am at Microsoft, a role that offers our team the autonomy to select our technology stack and own our projects end-to-end—from infrastructure at the VM and container level to requirement design, always treating security and compliance as non-negotiable foundations. It has been a rewarding journey so far, diving deep into everything from the fundamentals of authentication and public key infrastructure (PKI) to the consumer security domain. Working alongside AI as a co-developer has fundamentally transformed the development experience compared to years past. It is an incredibly exciting time to build, with boundless opportunities ahead for what we can create and deliver.
Two decades later, technology exists in an entirely different dimension. While I sometimes miss the days of sharing high-resolution photos on Flickr, it is incredibly exciting to connect with so many people who share my interests on Instagram and LinkedIn. Although the current wave of AI-generated “slop” is frustrating and makes finding genuine information difficult, I believe a consolidation is inevitable. Platforms will eventually adapt to user feedback, learning to surface what actually matters and letting low-effort content fade away, ultimately discouraging those looking for shortcuts.
I do miss the clean, chronological flow of linear email threads. Tools like Slack and Teams, with their constant stream of messages and bot notifications, can feel overwhelming. Yet, there is no denying they make us move faster. With a bit of self-discipline and clear team guidelines on what warrants attention, these channels can be highly streamlined. Indeed, we could never have survived the sudden shift to remote work during COVID-19 without the rapid advancement and adoption of video tools like Zoom and Meet, or collaboration hubs like Slack and Teams.
The convenience today is remarkable. I can reach government authorities with a single click and complete official transactions using Aadhaar authentication, eliminating the need to print endless photocopies. Airport travel is equally seamless: Digi Yatra allows me to bypass physical tickets and IDs entirely. I just show my face to pass through airport security scanners—no QR code needed until actual boarding (though a QR is still required while boarding).
It is truly an amazing time. I recently refactored a codebase for a pet project that I had struggled with for five years in just a single night using AI agents. I don’t even write down structured ideas anymore—I just “vibe code” it.
Ultimately, witnessing this twenty-year evolution of technology should help us better distinguish genuine innovation from temporary hype. Hopefully, this shared experience guides us to make the right investments rather than falling prey to knee-jerk reactions.
Handwritten by me, with grammar and typos corrected by AI.