Getting Placed and My University Expereience

Starting my blog

I’ve been meaning to start a blog for a while now. There’s always been this itch to put my thoughts down - about systems, my projects, and the rollercoaster of being a final-year student chasing after placements and a role I truly enjoy. I couldn’t think of a better way to begin than by sharing one of the biggest moments of my college life so far: getting placed.

In this post, I’ll talk about my journey through college - the grind, the constant shifts in interest.

New Beginnings

After finishing high school, I joined my undergrad majoring in Computer Science. Funny thing is, I initially wanted to go for Electronics and Communications, but the job market for those roles wasn’t looking too bright in my country. Since I already had a decent interest in Arduinos and writing code for them, I figured CS was the safer bet - or so I thought.

The first two semesters were a completely new experience. I suddenly had the freedom to explore what I wanted, but the curriculum still forced me into physics and chemistry (I’m still not sure how exactly they’re supposed to help me… maybe the connection will click one day). Around this time, I picked up C, got into low-level engineering, and started exploring reverse-engineering challenges (shout out to picoCTF). That’s when I discovered how much I enjoyed taking things apart just to see how they worked under the hood.

This was also when I entered my first hackathon. We got a crash course on Flutter and Figma, and then had 36 hours to build an app from scratch. I had zero experience with Flutter or Dart (and this was back in 2022, before ChatGPT blew up). My team and I scraped tutorials off YouTube and managed to make a simple app that took ingredients from your kitchen and suggested recipes. Honestly, it was more pretty UI than solid engineering, but for first-semester students without AI copilots, it was something. To our surprise, we ended up winning Best Implementation.

That day I learnt something important about myself: I work best under pressure. When there’s a hard deadline and something real at stake, I give it everything. It’s not a trait I’m especially proud of, but it’s shaped a lot of my college journey - sometimes successfully, sometimes not - as I kept trying to build discipline without external pressure.

Finding My Groove in CS

By the time I entered my 3rd semester, things started to feel serious. Seniors used to say, “this is where the real CS begins” - and they were right. I still remember the first time I implemented a linked list in pure C. It was like pulling back a curtain and realizing how much magic was hiding under the hood. For the first time, I wasn’t just using data structures - I was building them. That single experience lit a spark: I wanted to go deeper into low-level programming and see how everything actually worked.

Most of my 3rd and 4th semester was spent buried in textbooks on Operating Systems and Database Management Systems, and binge-watching lectures from other universities on YouTube. I wasn’t just studying for grades anymore - I was genuinely curious, and I wanted to absorb as much as possible.

In my 5th semester, I picked an elective called Big Data, and it completely changed the way I looked at storage. Until then, I hadn’t really thought about where large volumes of data lived or how they were managed. Learning about the Hadoop Distributed File System (HDFS) sent me down a rabbit hole into filesystems and the unique challenges of distributed environments.

But it was 6th semester that truly cemented my path. Two courses shaped everything:

1. Heterogeneous Parallelism - where I learned about CPU pipelines, cache coherence, and how different processing units could work together on the same program. It was my first real taste of computer architecture and performance engineering, and I couldn’t get enough.

2. Cloud Computing - where we explored virtualization, scalability, and the gnarly problems that arise in modern cloud systems. What fascinated me wasn’t just the problems, but how elegant some of the solutions were.

By the end of that year, I knew what I wanted to chase: distributed systems and performance engineering. And just as I was starting to feel like I’d found my groove, the biggest challenge of my undergrad life appeared on the horizon: placements.

Placements

For those outside India: placements (or on-campus recruiting) are when companies visit universities, conduct tests (usually LeetCode-style coding questions plus some OS/DBMS MCQs), and then interview shortlisted students. If you survive the whole gauntlet, you get the offer.

One company I had my eye on from the very beginning was Couchbase. They build distributed systems and their own database engine, basically the stuff I love. Unlike many companies, their hiring process is more personal: they don’t rely only on test scores. Instead, they manually go through resumes and call students who show strong fundamentals, demonstrated by projects, GPA, or past internships.

Here’s the catch: I had zero internships. My strength was projects, textbooks, and a decent handle on LeetCode. To my relief, I still got the interview call.

Preparing for Couchbase

I spent the days before revising core CS, walking through my projects’ source code, and brushing up concurrency concepts - mutexes, atomics, multithreading. This was my first serious interview, so the nerves were very real.

Round 1

The first interviewer made me comfortable, he was an alum of my university, so we started with a light chat. Soon, though, the technical discussion began. It centered around concurrency and multi-threading, two areas I’ve always been fascinated by. I could feel my nerves at play, but I managed to explain my thought process, touch on atomics, and even dive into some performance trade-offs. Looking back, this round taught me how important it is to stay calm while breaking down problems step by step.

Round 2

The second round was a deep dive into my projects. I got to walk through my shared-memory key-value store and talk about how I managed concurrency, race conditions, and design decisions. We also discussed systems-level scenarios where caching and efficiency matter, I really enjoyed this part because it felt close to the kind of problems I want to work on long term. While I took a little longer than I would’ve liked on one question, I felt I conveyed my reasoning well enough.

Round 3

By the third round, fatigue had set in, I’d been running on nothing but coffee for hours. This round explored my broader understanding of operating systems concepts and my ability to demonstrate them in code. I did blank out at one point, but with a small nudge I found my footing again. That moment reminded me how interviews aren’t just about knowing everything instantly, but about how you recover under pressure.

Results

Soon after, I received an offer from Couchbase for an internship. With their strong conversion rate to full-time, I was ready to move on to the next chapter.

Looking Ahead

Getting placed at Couchbase was more than just the end of the placement grind it was a validation of the path I’ve chosen: low-level systems, distributed computing, and performance engineering. The journey here was messy, full of detours, and very exciting.

Now that I finally have some breathing space before my internship begins, I want to channel this energy into writing. This story was personal, but from here on out, I’ll be sharing technical deep dives into the kind of topics that fascinate me: concurrency, operating systems, databases, performance, and distributed systems.

The first post in that series will explore a deceptively simple question: why isn’t count++ thread-safe? A single line of code that opens the door to race conditions, mutexes, atomics, and lock-free programming.

This is just the beginning, if you’ve read this far, thank you for joining me at the start of this journey.