How I Choose a Language

Over the years, I’ve worked with a wide range of programming languages and frameworks the biggest lesson I’ve is that you can build anything in anything. Whether it's Go, C#, or Node, the real magic isn’t in the language it's more about the developer using it than the language being used. That said, I tend to choose technologies based on the framework rather than the language itself.

🧠 Python — For Data Driven or ML Focused Projects

Python is my first pick when I’m dealing with data heavy projects or machine learning. With libraries like NumPy, pandas, and TensorFlow, and lightweight frameworks like FastAPI or Flask, it’s an amazing ecosystem. FastAPI, in particular, has become one of my favorites for building quick, async ready APIs.

⚙️ C# — For Speed and Structure

When raw performance and tight structure matter, I reach for C# and ASP.NET Core. It’s a great choice for building APIs or microservices with strong typing and robust tooling. With Entity Framework, you can bind data effortlessly, making it ideal for scalable and secure backend development.

🐹 Golang — The Microservice Powerhouse

Go is a beast when it comes to backend services. I mostly use it for microservices because of its speed, simplicity, and powerful standard library. Not to mention Golang has a very fast cold start that is only seconded by python and node. If possible I will try to run most of my microservices in Golang due to the speed, fast cold start times, and tiny .exe.

☕ Java/Kotlin — The Reliable Workhorse

I use Java mainly for niche purposes such as like machine learning which might raise a few eyebrows. Java has the most comprehensive libraries for Machine learning and if you train your files in python and convert them to Onyx files. You can actually run them in Java which is SUPER helpful for when you want to speed up inferencing.

🧩 Node.js — The Swiss Army Knife of the Web

Node.js is the duct tape, toolbox, and multi tool I constantly reach for not because it does one thing exceptionally well, but because it does everything reasonably well. It’s incredibly flexible and has earned its place as the glue between microservices, APIs, file handling, and frontend frameworks.

⚙️ Microservice Utility & Proxy Layer

I often use Node.js as a lightweight proxy routing traffic between services, acting as a gateway layer, or performing light transformations on requests. It's ideal for these glue tasks thanks to its event driven, non blocking architecture. Need to forward a request, manipulate a header, or stitch two services together? Node.js handles it effortlessly. 

Not to mention that because Node has a plethora of different libraries you will find a library in node that is only offerede in node. This is where microservices actually come into effect. 

📁 File I/O and Lightweight Tasks

Node also shines in scenarios involving file reads, streaming, data transformation, or moving files around anything where you need async behavior and not much business logic. But when it comes to complex data validation or schema enforcement, I tend to hesitate. JavaScript’s dynamic typing and loose structure can cause headaches when correctness and precision matter.

💡 Frontend Power: Node.js as the Backbone of Modern Web Apps

Node's real superpower lies in how it powers frontend frameworks. It’s the invisible engine behind tools like:

• React / Next.js

• Vue / Nuxt.js

• Vite

All of these depend on Node.js for tooling, server side rendering, hot module replacement, and build processes. In many ways, Node is the face of your frontend. It builds your site, powers your dev tools, and even runs your server side logic in frameworks like Next or Nuxt.

⚛️ React & Next.js — My Go To for Large Sites

I lean on React for component driven architecture, and when the site is large, content heavy, or SEO critical, Next.js is my default.

When I use Next.js:

• Static site generation (SSG) and incremental static regeneration (ISR)

• When I need SSR or hybrid rendering

• API routes baked into the frontend project

• Strong community and first class support for SEO

Next is great for marketing pages, blogs, dashboards, or anything that needs performance, scalability, and good dev ergonomics.

⚡ Vite — My Favorite for Dynamic Data Driven Apps

When performance matters and the project is data heavy rather than static, I opt for Vite.

Why Vite:

• Blazing fast hot module replacement (HMR)

• Great DX for building SPAs

• Plays nicely with both Vue and React

• More flexible when you want full control over the frontend/backend split

I often reach for Vite when building dashboards, internal tools, or dynamic UIs that talk heavily to an external API or backend.

🧪 Vue & Nuxt — The Slept On Enterprise Stack

Vue is incredibly approachable, and in enterprise environments where team scalability and maintainability matter, it holds up beautifully. People often sleep on Vue because it's not always as hyped as React but for maintainable large scale projects? It's fantastic.

And then there’s Nuxt.js, which I consider Vue’s answer to Next.js.

When I use Nuxt:

• Enterprise apps that need SSR, static generation, or hybrid rendering

• Developer experience that's highly refined

• File based routing and opinionated structure (great for teams)

Nuxt offers a clean, batteries included experience that just works, especially for apps that don’t want to reinvent the wheel.

Final Thoughts

Ultimately, use what works for you. Every tool has its strengths and tradeoffs. As long as you follow best practices and write clean, maintainable code, you’ll be in a good place no matter the language or framework.