My Tech Stack in 2025: A Deep Dive Into What Powers My Fullstack Projects

Choosing the right tools isn't just about hype or trends—it's about finding a tech stack that’s clean, composable, and scalable. As someone who builds fullstack applications end to end, I need tools that work well together, support rapid iteration, and don’t get in the way.

After experimenting with many options over the years, this is the tech stack I trust and use across all my current products in 2025. It's all TypeScript-based, and optimized for shipping fast without sacrificing quality or structure.

Frontend Stack

1. Next.js 15 (App Router, RSC)

Next.js continues to be the foundation of my web applications. The app/ directory and server components have matured, giving me a hybrid architecture where I can balance server-side performance with client-side interactivity.

• Why it works:

  • File-based routing is intuitive and flexible
  • Built-in API routes, edge functions, and middleware streamline development
  • Server Components and React Suspense simplify data-fetching logic

2. TailwindCSS

I build almost all interfaces with utility-first styling. Tailwind allows me to move fast, keep CSS scoped and predictable, and avoid naming fatigue.

• Key benefits:

  • Responsive design is quick and consistent
  • No CSS-in-JS overhead
  • Strong community and plugin ecosystem

3. Shadcn UI

For accessible, headless components that still look great, I layer in Shadcn UI. It uses Tailwind underneath and provides structured, customizable building blocks.

• Typical usage: Modals, toasts, tabs, forms, command palettes

4. React Query (TanStack Query)

All my frontend apps rely on React Query for managing server state. It provides a powerful abstraction over data fetching, caching, background syncing, and pagination.

• Why I prefer it over SWR or custom hooks:

  • Predictable cache behavior
  • Automatic refetching and stale data handling
  • Smooth developer experience with devtools

5. Zustand

While React Query handles server state, I use Zustand for local or global app state like modals, themes, filters, or UI toggles.

• Why Zustand:

  • Zero boilerplate
  • Doesn’t wrap components like context
  • Easy persistence with middleware

Mobile Stack

6. React Native with Expo

I maintain one shared TypeScript codebase for mobile using Expo. It’s mature, fast to iterate with, and integrates well with web technologies.

• Benefits:

  • OTA updates
  • Shared logic between web and mobile
  • Great developer tooling

7. NativeWind

This allows me to use Tailwind-like utility classes in React Native. It improves styling consistency and bridges the web/mobile design gap.

8. React Native Reusables

I maintain a personal set of reusable mobile components to speed up new projects. Think buttons, headers, modals, forms—built once, reused everywhere.

Backend Architecture

9. NestJS

NestJS powers all of my backend services. Built on top of Express (or Fastify), it offers a structured, modular, and testable TypeScript backend.

• Why NestJS:

  • Dependency injection out of the box
  • Modular folder structure scales well
  • Guards, interceptors, and pipes improve security and validation
  • Easy WebSocket integration

Database & Authentication

10. Supabase

Supabase provides my backend database (PostgreSQL), REST & GraphQL APIs, and real-time features.

• What I use Supabase for:

  • Database with SQL-level control
  • Supabase Auth for handling user accounts (email, OAuth)
  • Storage (for file uploads)
  • Row-Level Security for authorization

• Bonus:
  
  Supabase’s dashboard, CLI, and local development support are mature and intuitive.

Hosting & Infrastructure

11. Railway

All backend and frontend apps are deployed via Railway. It abstracts a lot of DevOps while allowing full control over environment variables, logs, metrics, and deployments.

• Why I use it:

  • Clean UI for managing environments
  • Git-based deploys
  • Easy database provisioning
  • Ideal for solo developers and small teams

AI Integrations

12. OpenAI API (LLM + Vision)

I integrate OpenAI for natural language understanding and image processing. GPT-4 handles summarization, completion, and contextual tasks. Vision APIs enhance user uploads and interactions.

13. Deepinfra

Deepinfra provides access to LLaMA models as well as TTS and STT features. I use this when I want more control over cost or prefer models not hosted by OpenAI.

14. Anthropic API

Claude is used in places where I need more focused summarization or longer context retention. It’s helpful for assistant-like features with a more measured tone.

Payments & Billing

15. RevenueCat

For mobile apps with subscriptions, I rely on RevenueCat. It handles cross-platform in-app purchases, subscriber management, and integrations with analytics tools.

16. Lemon Squeezy

On the web side, Lemon Squeezy handles subscription billing, taxes, receipts, and licensing logic. The API is modern, and the checkout flow feels polished.

Developer Tooling

17. Cursor AI

I use Cursor as my IDE. It’s a fork of VS Code, but tailored for AI-assisted development. It's fast, context-aware, and works well for refactoring large codebases.

• Why Cursor over Copilot in VS Code:

  • Full-codebase context
  • More natural pair programming experience
  • Easier to prompt for file-level or project-wide changes

Conclusion

This stack reflects my priorities in 2025: simplicity, speed, scalability, and full control with minimal overhead. Every tool here solves a real problem without introducing unnecessary complexity.

Sticking to one language—TypeScript—across the stack allows me to build full applications, switch between contexts quickly, and maintain quality without wasting time on glue code or language mismatches.

If you're building as a solo developer or want a clean foundation for your next product, I believe this setup offers a pragmatic path from idea to production.

Want to dive deeper into how I build products from scratch?
Check out my projects and learning resources here:
📚 https://codewithdhanian.gumroad.com
📍 Follow me on X: @e_opore