DEV Community: Aaditya Chowdhury

How I Ended Up Working as a Lead Dev for a Philips Project in College

Aaditya Chowdhury — Thu, 14 Aug 2025 09:50:51 +0000

A few months into my final years of college, I was looking for my next big challenge. The last startup I worked at as a founding engineer had just been acquired, and I was itching to build something meaningful again.

That’s when I came across a posting from Ownpath Studios. I applied, interviewed, and to my surprise got an offer letter almost immediately. The role? Lead developer on a healthcare project for Philips.

For an undergrad who’d never even been to Bangalore before, this was huge. Within weeks, I had my tickets booked and was walking into the Philips Innovation Campus in Bangalore for the first time.

Walking into Philips for the First Time

The office was massive. I still remember sitting in a meeting room surrounded by senior developers, UI architects, and even the Director of Philips Innovation. I was the youngest in the room, but I wasn’t just there to observe. I had complete ownership of the project’s codebase.

The product was fascinating, a healthcare app where a user could place their finger on their phone camera and get real time vitals like heart rate, blood pressure, and respiration rate. Over time, the app could even predict conditions like diabetes, high BP, and sleep apnea based on daily scans.

I was building it solo.

From Design to Code

We used Careplix, a medical SDK, for the finger scan vitals detection. On top of that, I built the app in React with an Express middleware, styled with TailwindCSS.

One of the biggest challenges, and the part I’m most proud of was the UI implementation. Ownpath’s in house designers had crafted an incredibly polished interface in Figma, and it was my job to translate it into pixel perfect code. Every border, shadow, and animation had to match exactly. We went through revision after revision until it was flawless.

Final UI screen from the Philips healthcare app I built

And I didn’t just stay in the front end lane. I built core disease prediction APIs from scratch. I pulled from open source medical questionnaires and datasets, compiling them into an inference engine that could provide deeper health predictions the more a user engaged with the app.

Two Hero Moments I’ll Never Forget

There were moments that still feel surreal. Like the first big demo at the Philips office, where I projected the app live on a big screen in front of a room full of senior engineers, architects, and managers, testing scans in real time while explaining how it all worked.

Or the time I was on my way to a critical demo and found a last-minute bug. I ended up fixing code in the back seat of a car, hotspotting from my phone, and pushing the patch minutes before the meeting. The demo went perfectly.

Six Months That Changed Everything

Six months went by in a blur, countless UI updates, testing cycles, and all nighters. Slowly, the app started feeling less like a student project and more like a real, production grade healthcare product.

This was the first time I was working on something that could impact thousands of users. And while the technical skills I learned were invaluable, advanced React patterns, API design, SDK integration, the biggest lesson was how to manage a large scale project entirely on my own.

Looking Back

That Philips project was a turning point for me. It taught me that even as an undergrad I could walk into a room of experts, hold my own, and ship something that truly mattered.

And for that, I’ll always be grateful to the Ownpath Studios team for the opportunity.

Understanding the Event Loop in JavaScript — Made Simple!

Aaditya Chowdhury — Wed, 16 Oct 2024 19:25:55 +0000

JavaScript is one of the most popular programming languages, powering around 90% of websites on the web! But, one of the trickiest and most misunderstood concepts is how the event loop works. Here is an easy explanation for event loop, task queue, call stack, microtask queue, and web APIs.

What Makes JavaScript Special?

JavaScript is a single-threaded language. This means it processes one thing at a time, unlike languages like C++ or Go, which can handle multiple things concurrently. To make asynchronous tasks like fetching data or running timers work smoothly, JavaScript uses something called the event loop!

1. What Are Web APIs?

Web APIs are extra tools provided by the browser or Node.js to handle tasks like making network requests (using fetch), setting timers (setTimeout), or accessing user location (using the Geolocation API). These tasks run outside the main JavaScript thread.

Example:

setTimeout(() => {
  console.log("Timer done!");
}, 2000);

Here, the browser handles the timer while the main JavaScript continues running other code.

2. What is the Task Queue?

The Task Queue is where callback functions from Web APIs, event listeners, and other deferred actions wait until JavaScript is ready to run them. These tasks wait their turn in line.

Think of it like a waiting line at a store, each task gets processed by the event loop when JavaScript is done with the current task.

3. What is the Call Stack?

The Call Stack is where JavaScript keeps track of function calls. When you call a function, it gets pushed onto the stack. When it finishes, it’s popped off. JavaScript processes tasks in the order they appear in the stack, it’s synchronous by nature.

4. What is the Event Loop?

The Event Loop is like a traffic officer that keeps everything moving. It constantly checks whether the call stack is empty, and if it is, it moves tasks from the task queue or microtask queue to the stack for execution. This is what lets JavaScript handle asynchronous code without blocking the main thread.

Example of Event Loop in Action

setTimeout(() => {
  console.log("2000ms");
}, 2000);

setTimeout(() => {
  console.log("100ms");
}, 100);

console.log("End");

What happens here?

Let’s break it down:

"End" is logged immediately since it's synchronous and runs in the call stack.
The setTimeout with 100ms is handled by the Web API. After 100ms, its callback moves to the task queue.
The setTimeout with 2000ms does the same, but its callback moves to the task queue after 2000ms.
The event loop moves the 100ms callback to the call stack first, then the 2000ms callback.

5. What is the Microtask Queue?

The Microtask Queue is a special queue for tasks that are processed before the task queue. Microtasks come from things like Promises or mutation observers. The event loop always checks the microtask queue before the task queue.

Microtask Example with Promise

console.log("Start");

setTimeout(() => {
  console.log("Timeout");
}, 0);

Promise.resolve().then(() => {
  console.log("Promise");
});

console.log("End");

What happens here?

"Start" is logged immediately.
The setTimeout callback is placed in the task queue.
The Promise resolution is placed in the microtask queue.
"End" is logged.
The event loop checks the microtask queue, executes the Promise callback.
Finally, the task queue processes the setTimeout callback.

Output:

Start
End
Promise
Timeout

Visual Representation

Wrapping It All Up

Here’s how everything fits together:

Web APIs handle async tasks like timers outside the main thread.
The Event Loop moves tasks from the Task Queue or Microtask Queue to the Call Stack.
Microtasks (like promises) are handled first, before tasks in the Task Queue.

From Intern to Frontend Developer to Selling a Company in College

Aaditya Chowdhury — Wed, 16 Oct 2024 18:19:22 +0000

It all started in my 5th semester of undergrad. I was desperately looking for internship opportunities amidst a tough job market due to the recession. After applying to various companies without much luck, I stumbled upon a tweet about a dev intern position. Without hesitation, I applied. Before this, I had some experience with the MERN stack and a bit of Python.

A call from Priyanshu at Symmulate Labs changed everything. He told me about an exciting project they were building with Buildspace — an application that creates personalized avatars of famous internet personalities, allowing people to interact with them. I was amazed! They were using RVC voice models and LLMs (Large Language Models) to achieve this. Soon enough, I was onboarded and started designing a cool frontend in Figma and coding it in just a few days. Then, I dived into the backbone of the project: voice conversion. I spent almost two months working on voice conversion models and creating the LLM agent.

By the end of this phase, we had a solid product. It wasn’t perfect, but it worked like a charm. Although we didn’t succeed in the subsequent Buildspace rounds, we focused on attracting more customers and improving the product. We even built a prototype where you could talk to Sadhguru, and it replicated his voice perfectly!

After four months with the team, despite our best efforts, it felt like we had hit a dead end. My internship ended, and I started looking for more opportunities. I secured a remote SWE internship at Gastrogate in Sweden, which made me incredibly happy! But that’s a story for another day.

Out of the blue, Priyanshu called me again with another project idea: an AI-based education platform. This intrigued me as my friends and I had previously tried to build something similar named Aadhya AI. I was hesitant at first, worried about managing so much work and college simultaneously, as I was working full-time with Gastrogate. But I couldn’t let go of such an amazing opportunity, so I said YESSSS.

We started working on the platform immediately. I was coding the frontend, sometimes working 14–16 hours a day. I attended my college lectures for 4–6 hours and spent the rest of the time sitting on my desk, working. We built various chatbots with different capabilities to pitch to companies. The core feature was an AI doubt solver capable of handling university-level STEM questions, generating notes, questions, and more!

Then we hit another roadblock: LLMs were terrible at math. Our competitors had around 50–55% accuracy, and we needed to surpass that to succeed. Priyanshu went all out, pitching our product to book publishers, companies, and even the NCERT office in Delhi! Despite reading numerous blogs, research papers, and consulting with experts, the problem seemed unsolvable. Everyone was stuck where we were.

We brainstormed countless ideas and implemented several of them. We tried Mistral open-source models, OpenAI models, and created an LLM agent. After countless hours, I felt like an LLM guru😎. One approach that worked was separating the mathematical calculations from the questions, solving them using Python, and integrating the results with the Tutor chatbot (sounds simple, right? Not so much to implement 💀). After thousands of lines of prompt engineering and coding, we finally achieved 20% more accuracy than our competitors. It wasn’t as high as we aimed, but it was a significant achievement.

Priyanshu began searching for potential buyers or investors. After numerous meetings and iterations on our chatbot, in May, I received a text: Adda 247, one of the biggest ed-tech firms, wanted to collaborate with us on the project. I was ecstatic! A product I helped build impressed such a major player. Still in college, I had contributed to something that could impact many people.

I remember late nights, staying up until 4 am, working on the chatbot. Priyanshu was always there, working alongside me, and providing support and guidance. Without him, none of this would have been possible. He is one of the coolest and most talented people I have ever met.

This was my journey from learning HTML in my first semester to selling a startup to an ed-tech firm while still in college. I look forward to building more amazing products in the future!

Check out Priyanshu here: Priyanshu on LinkedIn and the rest of the Symmulate Labs Team who made this possible.