Today, June 14, 2025, marks three full years since I officially became a developer. From my first Git commit on June 14, 2022, to today and into the future — this post captures my journey: the timelines, challenges, breakthroughs, and how React fundamentally transformed the way I think about software engineering. This is not just a technical retrospective but also a philosophical one — a record of how my mindset, understanding of systems, and development practices have matured over time.

2022: The First Touch — Curiosity Meets Complexity

I first encountered React in mid-2022. React 18 had just been released with major updates like automatic batching, startTransition, and streaming server-side rendering. At the time, I couldn't appreciate how groundbreaking these features were — I was simply trying to understand useState, useEffect, and the structure of JSX. Everything felt foreign. JSX looked like broken HTML. Hooks were overwhelming. And debugging felt like solving abstract puzzles.

My first experience was through Create React App (CRA), the go-to boilerplate for beginners back then. It offered predictability and structure, but my first encounter with Redux quickly soured me. It felt verbose and overengineered. The boilerplate alone made me feel like I was writing more code for setup than features. I dropped it, unsure if I'd return.

Still, every build was a learning opportunity. I recall the thrill of seeing my first map() function render a list, or understanding the DOM repaint cycle when toggling a state. Those small wins — though technically simple — were profound back then.

2023: Ecosystem Evolution and Developer Awareness

2023 was the inflection point in my journey. I started noticing the React ecosystem evolving at an incredible pace. Create React App was being gradually phased out, and community guidance began favoring Next.js and Vite. Taking that leap into Next.js exposed me to concepts like file-based routing, API routes, and server-side rendering — all consolidated under one elegant framework. It felt like discovering a new superpower.

During this time, tools like Turbopack and SWC became more common. Built in Rust, they replaced traditional compilers like Webpack and Babel with far better performance and developer experience. Hot reloads became near-instant. Build times were slashed. Everything just felt smoother.

Meanwhile, I switched from npm to Yarn. I had been struggling with dependency errors, inconsistent installs, and version mismatches. Yarn brought much-needed stability and speed to my workflows, and I haven't looked back since.

This was also the year I started building more robust applications — dashboards, landing pages, experimental products — and every new project taught me something vital: component hierarchy, prop drilling, reusable hooks, error boundaries, and performance optimization.

The Spark: React Query & System Thinking

One of the most transformative discoveries came when I found React Query. Like many, I was initially managing data fetching using fetch inside useEffect, then tracking loading and error states manually. It was repetitive and messy.

React Query — now known as TanStack Query — changed everything. Suddenly I had tools for caching, background refetching, pagination, and query invalidation. It abstracted the hard parts of data management and gave me patterns that felt scalable.

That day marked a shift. I wasn't just writing code — I was designing systems. I went down the rabbit hole of production-ready topics: cache invalidation, stale-while-revalidate strategies, and API synchronization. These weren't just fancy features — they were critical design decisions. It was the first time I felt like I was thinking like a real engineer.

The Shadcnification Phase: UI as Engineering

While my logic and systems matured, so did my eye for interface design. Enter shadcn/ui, a beautiful component library built on Radix UI primitives and Tailwind CSS. Using it reshaped my perception of front-end development.

I began to appreciate UI not just as a final polish but as a critical part of the user experience architecture. The components were accessible, scalable, and easy to customize. I stopped copy-pasting from random libraries and started curating my own design system — focusing on layout fluidity, color contrast, motion, and responsiveness.

I called this stage the Shadcnification of my code. Every application started looking and feeling more thoughtful — from hover transitions to focus outlines. Design became a craft, not an afterthought.

2024–2025: Full Stack Confidence and Simplicity First

By 2024, I wasn't just building apps — I was designing scalable architectures. I adopted Next.js 13/14 with App Router, Server Components, and the Actions API. Turbopack became deeply embedded in my workflow. I had stopped treating projects like temporary playgrounds and started approaching them like real products.

I explored the backend in depth:

• Supabase for instant PostgreSQL + Auth
• Prisma ORM for data modeling
• Rate limiting, middleware, and edge functions
• Database optimization, pagination, and background jobs

But perhaps the most powerful realization during this time was a simple one:

"No matter what the project is, you should avoid complexity at all costs."

This quote is pinned on my GitHub and now guides every project I work on. I learned this the hard way — from maintaining projects that were too clever for their own good. Abstractions that no one could understand. Folder structures that prioritized theoretical purity over clarity.

And then I came across this quote by Terry A. Davis, creator of TempleOS:

"An idiot admires complexity, whereas a genius admires simplicity."

It changed everything. From that point on, my goal became building clean, elegant, and transparent systems. I stopped chasing novelty and started chasing clarity. I stopped solving problems I didn't yet have.

Looking Forward — Always in Beta

From useState to server actions, from copying YouTube tutorials to writing reusable systems, the past three years have taught me more than I could have ever predicted.

React, to me, is not just a library — it's a way of thinking about problems. It helped me develop my design sense, logic, and architectural judgment. It gave me a framework not just for building interfaces, but for building thoughtfully.

Each line of code was a breadcrumb on a longer trail of exploration. Each bug revealed what I didn't yet understand. Each successful deploy gave me the confidence to reach higher.

And the best part? This is just the beginning.

Here's to simpler code, better systems, and more sparkly moments ahead. ✨