Choosing a tech stack as a full-stack developer isn’t just about following the latest trends. It’s about finding the right balance between flexibility, maintainability, performance, and what feels natural to work with. Over the years, I’ve built everything from web apps to mobile apps and desktop software, and through trial and error, I’ve settled on a stack that fits my workflow and problem-solving style. In this post, I’ll share my stack and why I use each piece, giving you a peek into how I approach building software across platforms.
Backend: The Engine of My Projects
For the backend, I mainly work with Django and Node.js. Both bring unique strengths, and together they give me flexibility depending on the type of project.
I lean on Django when I need a reliable, scalable backend quickly. Its built-in admin panel and powerful ORM make development smooth, letting me focus on the core business logic instead of reinventing the wheel for things like authentication or database interactions. The “batteries included” philosophy is perfect for projects where I want speed without sacrificing maintainability.
On the other hand, Node.js shines when concurrency or real-time features are needed. Its event-driven architecture makes handling multiple requests easy, which is great for chat apps, notifications, or streaming services. Using Express on top of Node.js allows me to create RESTful or GraphQL APIs quickly, which plug seamlessly into frontend frameworks.
Combining Django and Node.js gives me the best of both worlds: Django handles structured, data-heavy applications, while Node.js covers high-performance, lightweight services. This way, I can pick the right tool for the job.
Web: React and HTMX
For the web, I mainly use React.js to build dynamic and responsive interfaces. Its component-based approach makes it easy to reuse elements across the app and maintain consistency. The React ecosystem—Redux, React Query, and Tailwind CSS—helps me handle state, data fetching, and styling efficiently.
But I don’t rely on client-side rendering alone. For cases where SEO and fast initial loading are important, I use Django with HTMX for server-side rendering (SSR). HTMX allows me to build interactive interfaces without overloading the client with JavaScript. Using React for SPAs and HTMX for lightweight SSR gives me flexibility: I can choose the approach that fits each part of a project.
This hybrid strategy also makes maintenance easier. Smaller sections of a site that don’t need full SPA behavior can use HTMX for quick updates, keeping things fast and simple.
Mobile: React Native with Expo
When it comes to mobile apps, my stack revolves around React Native and Expo. React Native lets me write one codebase in JavaScript/TypeScript that runs on both iOS and Android, saving a lot of development time compared to building native apps separately.
Expo makes this even easier. Its managed workflow handles common mobile features—push notifications, camera access, OTA updates—so I can focus on building the app itself. Maintaining one codebase for both platforms while still getting near-native performance is a huge productivity boost, especially for solo projects like mine.
Desktop: Electron Across Platforms
Desktop apps are another dimension of my work. For this, I use Electron, which lets me bring my web skills to Windows, macOS, and Linux applications.
Electron’s simplicity is its strength. I can reuse React components, write in JavaScript/TypeScript, and package everything as a cross-platform desktop app. This is perfect for productivity tools, internal dashboards, or desktop clients for web services. It saves time and ensures consistency across operating systems.
Languages: Python, JavaScript, and TypeScript
Behind all of this are three core languages: Python, JavaScript, and TypeScript. Python powers my Django backend with clarity and an extensive library ecosystem. JavaScript runs my web and desktop frontends, and TypeScript adds type safety, catching errors early and making code easier to maintain.
These languages let me move between backend, web, mobile, and desktop without constantly switching gears. It’s a stack that adapts as I grow and tackles new challenges while staying consistent.
Why This Stack Works for Me
The common thread across all of this is efficiency. I choose tools that solve problems effectively, not just what’s trendy. Django gives me structure, Node.js gives concurrency, React makes interfaces responsive, HTMX keeps SSR lightweight, React Native with Expo handles mobile, and Electron bridges web and desktop. Python, JavaScript, and TypeScript tie it all together.
My stack reflects that journey—shaped by projects, mistakes, and lessons learned. It’s not perfect, and it will evolve, but for now, it lets me build across platforms, solve problems creatively, and keep growing as a developer.