🌟 The Beginning: Stepping Into the Unknown
When I walked into the company in January 2023 as an intern, I had no idea I was about to embark on one of the most transformative experiences of my career. Like most interns, I started with the basics – watching YouTube videos about Spring Boot, building demo projects, and trying to understand what this company actually did.
But curiosity has always been my driving force. Instead of just completing assigned tutorials, I found myself diving deep into the Android SDK codebase that powers push notifications for millions of users. As I traced through functions that handled app lifecycle events and notification delivery tracking, something clicked. This wasn't just code – this was the invisible infrastructure keeping users connected to the apps they love.
Those early days of code exploration led to my first real contribution. While reading through the SDK, I started noticing bugs – small inconsistencies that others had missed. Each bug I reported felt like solving a puzzle, and my manager began to notice my attention to detail. Soon, I wasn't just reading code; I was understanding the entire ecosystem – from Google Services configurations to FCM backends, from testing on PCloudy devices to crafting perfect Postman requests for push notifications.
⚡ The First Real Challenge: When Background Services Met New Android APIs
My first major project arrived sooner than expected. Android was updating its API requirements, and our legacy background services needed to migrate to WorkManager. I saw it as an opportunity to leave my mark on something real – something that would actually run in production and serve real users.
The migration wasn't just about changing APIs; it required understanding the fundamental differences in how Android handles background processing. I spent days reading documentation, testing different approaches, and ensuring backward compatibility. When the SDK finally shipped with my changes, I felt something I'd never experienced before – the pride of knowing that somewhere in the world, users were receiving notifications because of code I had written.
But the journey didn't stop there. The Android changes needed to propagate to our React Native SDK too. Suddenly, I was learning cross-platform development, understanding how native modules bridge to JavaScript, and managing release processes across multiple platforms. Each release taught me something new about the intricate dance between different technologies.
🧪 The Experiment That Sparked Innovation
Around this time, my manager approached me with an experimental idea – what if we could build a system where the SDK itself could pull notifications that FCM failed to deliver? It was ambitious, requiring changes to both the SDK and backend infrastructure. Since the backend wasn't ready, we built a dummy API that returned the same notifications repeatedly. It seemed simple, but it was laying the groundwork for something much bigger.
Working directly with my manager on this experiment taught me about the importance of proof-of-concepts and iterative development. We weren't just building features; we were exploring possibilities and pushing the boundaries of what mobile notification systems could do.
🔥 Trial by Fire: The On-Call Experience That Changed Everything
Then came the moment that would define my internship – and arguably my entire career trajectory. I became the first intern in company history to join the on-call rotation. My manager believed in me enough to let me experiment with whether interns could learn from the intense, real-world pressure of production support.
Those first few weeks were brutal. I was thrown into the deep end of systems I barely understood – CDP flows, MA backend processes, and complex client integrations that I'd only heard about in passing. Every ticket felt like a mountain to climb. I'd spend hours reading through codebases, tracing execution paths, and trying to understand how data flowed through our systems.
The senior engineers were helpful when they could be, but they had their own fires to fight. So I developed a different approach – I would dive into the code directly, reading entire applications from top to bottom until I understood not just what they did, but why they did it that way. This self-directed learning approach became my superpower.
Week after week, I was primary on-call with barely any breaks. It was exhausting, but it was also exhilarating. Each resolved incident taught me something new about system behavior, about how to read logs effectively, about the difference between temporary fixes and root cause solutions. I was developing an intuition for troubleshooting that would serve me for years to come.
By the end of my internship, I had accidentally become one of the most knowledgeable people about the company's core backend flows – knowledge that typically took engineers months to acquire.
🏗️ Beyond Code: Infrastructure and Optimization
Between incidents, I found myself working on infrastructure improvements alongside our principal engineer. Our AWS setup had evolved organically, with separate load balancers for different applications – but since our traffic wasn't that high, separate load balancers were unnecessary and costly. The principal engineer identified this inefficiency and guided me through implementing a consolidation strategy, moving to single load balancers with intelligent routing rules for both production and staging environments, significantly reducing our infrastructure costs.
I also worked with him to set up proper monitoring for several production applications that lacked visibility. Together, we implemented Monit and Node Exporters across these systems, dramatically improving our ability to monitor application health. These weren't glamorous tasks, but they were the kind of foundational work that prevents 3 AM outages.
Continue the Journey
See how this internship foundation led to even greater challenges and achievements