Technology Stacks Directory
Discover proven technology stack combinations for modern applications. Explore frontend, backend, full-stack, and specialized stacks.
MERN Stack
MongoDB, Express.js, React, Node.js - Full-stack JavaScript solution
MEAN Stack
MongoDB, Express.js, Angular, Node.js - Enterprise JavaScript stack
LAMP Stack
Linux, Apache, MySQL, PHP - Classic web development stack
JAMstack
JavaScript, APIs, Markup - Modern web architecture
T3 Stack
Next.js, TypeScript, Tailwind, tRPC, Prisma - Type-safe full-stack
PERN Stack
PostgreSQL, Express.js, React, Node.js - Relational DB full-stack
AWS Serverless Stack
Lambda, API Gateway, DynamoDB, S3 - AWS serverless architecture
Cloud Native Stack
Kubernetes, Helm, Istio, Prometheus - CNCF ecosystem
Modern Data Stack
Snowflake/BigQuery, dbt, Airflow, Looker - Analytics pipeline
MLOps Stack
MLflow, Kubeflow, TensorFlow, Feature Store - ML lifecycle
Django HTMX Stack
Django, HTMX, Alpine.js - Modern Python web stack
Rails Hotwire Stack
Ruby on Rails, Hotwire, Turbo - Rails 7+ modern approach
Phoenix LiveView Stack
Elixir, Phoenix, LiveView - Real-time without JavaScript
Go Microservices Stack
Go, gRPC, Kubernetes, PostgreSQL - High-performance services
Rust WASM Stack
Rust, WebAssembly, Yew - High-performance web apps
Edge Computing Stack
Cloudflare Workers, D1, R2, KV - Edge-first architecture
Supabase Stack
Supabase, Next.js, Tailwind - Open source Firebase alternative
Spring Cloud Stack
Spring Boot, Spring Cloud, Kubernetes - Enterprise Java
.NET Azure Stack
ASP.NET Core, Azure Services, SQL Server - Microsoft ecosystem
Flutter Firebase Stack
Flutter, Firebase, Cloud Functions - Cross-platform mobile
MEVN
A JavaScript fullstack combining MongoDB, Express, Vue, and Node.js for single-page web apps with one language end to end.
LEMP
A classic web stack of Linux, Nginx, MySQL, and PHP that serves dynamic sites with high concurrency and low overhead.
Next.js + Supabase
A fullstack pairing Next.js with Supabase for Postgres, auth, storage, and realtime, shipping production apps with minimal backend code.
Next.js + Prisma + Postgres
A typed fullstack of Next.js, the Prisma ORM, and PostgreSQL for SaaS apps with a hand-owned backend and end-to-end type safety.
Remix + Postgres
A web stack built on Remix's loader/action model over PostgreSQL, embracing web standards and progressive enhancement for fast, resilient apps.
SvelteKit Fullstack
A fullstack framework using SvelteKit for compiled, reactive UIs with server routes, ideal for fast, lightweight web applications.
Astro + Headless CMS
A content stack using Astro's island architecture with a headless CMS to ship fast, mostly-static sites with selective interactivity.
Nuxt + Strapi
A Vue-based stack pairing the Nuxt framework with the Strapi headless CMS for content-driven sites and apps with a customizable backend.
RedwoodJS
An opinionated fullstack JavaScript framework integrating React, GraphQL, and Prisma into one convention-driven project for startups.
Laravel + Vue
A PHP fullstack pairing the Laravel framework with a Vue front end, often via Inertia, for productive, full-featured web applications.
Rails + Hotwire
A server-driven Ruby on Rails stack using Hotwire (Turbo and Stimulus) to build reactive web apps with minimal custom JavaScript.
Django + React
A decoupled stack with a Django REST backend and a React front end, separating API and UI for flexible, scalable web applications.
Phoenix LiveView
An Elixir stack using Phoenix LiveView to build real-time, server-rendered interactive UIs over WebSockets with little JavaScript.
ASP.NET + Blazor
A .NET stack pairing ASP.NET Core with Blazor to build interactive web UIs in C#, sharing code across server and client.
Spring Boot + Thymeleaf
A Java stack pairing Spring Boot with the Thymeleaf template engine for server-rendered web applications with robust enterprise tooling.
FastAPI + React
A modern Python stack with a FastAPI backend and a React front end, joining high-performance async APIs to a rich interactive UI.
Angular + NestJS
A TypeScript stack pairing the Angular front end with the NestJS backend, sharing patterns and types for structured enterprise apps.
SolidStart
A fullstack framework built on Solid's fine-grained reactivity, offering SSR, server functions, and high performance with a React-like API.
Blitz.js
A fullstack toolkit on top of Next.js that removes the API layer with typed server-side queries and mutations for rapid app building.
Vue + Nuxt + Pinia
A Vue-centric fullstack using Nuxt for SSR and server routes with Pinia for state management, for SEO-friendly interactive web apps.
Elixir + Phoenix
A backend-focused web stack using Elixir on the BEAM with the Phoenix framework for highly concurrent, fault-tolerant web services.
JAMstack (Headless)
An architecture of pre-rendered markup, JavaScript, and APIs that decouples the front end from services for fast, secure, scalable sites.
HTMX + Go
A hypermedia-driven stack pairing HTMX with a Go backend to build interactive web apps using HTML over the wire and minimal JavaScript.
Django + DRF
A Python backend stack combining Django with Django REST Framework to build secure, well-structured REST APIs and admin-driven apps.
Qwik City
A resumable fullstack framework using Qwik and Qwik City to deliver instant-loading apps with near-zero JavaScript via lazy execution.
Spring Boot Enterprise Stack
Java backend stack built on Spring Boot with PostgreSQL and Redis for production REST services and enterprise applications.
.NET Web API Stack
Modern C# backend stack using ASP.NET Core, Entity Framework Core, and SQL Server or PostgreSQL for high-performance cross-platform services.
FastAPI + SQLAlchemy Stack
Async Python backend stack using FastAPI, SQLAlchemy, and PostgreSQL for high-performance, type-hinted REST and ML-serving APIs.
Go + gRPC Stack
Compiled Go backend stack using gRPC and Protocol Buffers with PostgreSQL for fast, strongly-typed inter-service communication.
Go + Gin + Postgres Stack
Lightweight Go REST backend using the Gin web framework with PostgreSQL and Redis for fast, simple, high-throughput HTTP APIs.
Node + Express + Mongo Stack
JavaScript backend stack using Node.js, Express, and MongoDB for flexible, schema-light REST APIs and rapid prototyping.
NestJS + Postgres Stack
Structured TypeScript backend stack using NestJS with PostgreSQL and an ORM for scalable, modular, enterprise-grade Node.js services.
Rails API Stack
Ruby on Rails backend in API mode with PostgreSQL and Redis for convention-driven, fast-to-build REST services and SaaS backends.
Quarkus Cloud-Native Java Stack
Cloud-native Java backend using Quarkus with GraalVM native compilation and PostgreSQL for fast-starting, low-memory containerized services.
Micronaut JVM Microservices Stack
JVM microservices stack using Micronaut with ahead-of-time compilation and PostgreSQL for low-memory, fast-starting services and serverless functions.
Ktor Kotlin Backend Stack
Asynchronous Kotlin backend using the Ktor framework with PostgreSQL and coroutines for lightweight, idiomatic, non-blocking services.
Rust Axum/Actix Backend Stack
High-performance, memory-safe Rust backend using Axum or Actix with PostgreSQL for low-latency, resource-efficient services.
Phoenix Elixir Stack
Concurrent Elixir backend using the Phoenix framework on the BEAM VM with PostgreSQL for fault-tolerant, real-time, highly concurrent services.
Kubernetes + Istio Service Mesh Stack
Cloud-native platform stack pairing Kubernetes orchestration with the Istio service mesh for traffic management, security, and observability.
Knative Serverless Containers Stack
Kubernetes-based serverless stack using Knative for scale-to-zero, request-driven container workloads with event-driven autoscaling.
AWS Serverless Stack
Fully managed AWS serverless stack using Lambda, DynamoDB, and API Gateway for event-driven, pay-per-use applications with no server management.
Azure Serverless Stack
Managed Microsoft Azure serverless stack using Azure Functions and Cosmos DB for event-driven, globally distributed, pay-per-use applications.
GCP Serverless Stack
Google Cloud serverless stack using Cloud Run and Firestore for container-based, scale-to-zero applications with managed NoSQL storage.
Kafka + Flink Streaming Stack
Real-time stream processing stack pairing Apache Kafka for durable event streams with Apache Flink for stateful, low-latency computation.
Event-Driven Microservices Stack
Asynchronous microservices architecture using Kafka as an event backbone with independently deployable services for loose coupling and scalability.
gRPC Service Mesh Stack
Microservices stack combining gRPC inter-service communication with a service mesh on Kubernetes for typed, observable, secure service-to-service traffic.
Dapr Distributed Application Stack
Polyglot microservices stack using Dapr building blocks for service invocation, state, pub/sub, and bindings, abstracted from underlying infrastructure.
Serverless Containers Stack
Cloud stack running standard OCI containers on managed serverless platforms for scale-to-zero, pay-per-use workloads without cluster management.
AWS ECS Fargate Containers Stack
Managed container stack running Docker workloads on AWS ECS with Fargate serverless compute, behind a load balancer, without managing servers or clusters.
Modern Data Stack (ELT)
Cloud-native ELT pattern: managed ingestion loads raw data into a warehouse, where dbt transforms it and a BI tool serves analytics.
dbt + BigQuery Analytics Stack
Serverless analytics engineering on Google BigQuery with dbt managing SQL transformations, tests, and lineage on top of warehouse-native compute.
Databricks Lakehouse
Unified lakehouse architecture combining data-lake storage with warehouse reliability via Delta Lake, Spark compute, Unity Catalog governance, and ML.
Kafka + Flink + Iceberg Streaming Stack
Real-time streaming architecture: Kafka transports events, Flink processes them with stateful low-latency compute, and Iceberg lands them in an open lakehouse.
Airflow + Spark Batch Pipeline Stack
Classic big-data batch pattern: Apache Airflow orchestrates scheduled DAGs that run distributed Apache Spark jobs over data-lake storage.
MLflow MLOps Stack
End-to-end MLOps pattern using MLflow for experiment tracking, model registry, packaging, and deployment, integrated with feature, data, and serving layers.
RAG Stack (LangChain + pgvector + LLM)
Retrieval-augmented generation stack: LangChain orchestrates retrieval over pgvector embeddings in Postgres and grounds an LLM's answers in your own data.
Kubeflow ML Platform
Kubernetes-native ML platform: Kubeflow Pipelines, training operators, KServe serving, and Katib tuning run the ML lifecycle on Kubernetes.
Feast Feature Store Stack
Feature store pattern using Feast to define, materialize, and serve consistent ML features from an offline warehouse and a low-latency online store.
ELK Analytics Stack
Elasticsearch, Logstash, and Kibana for ingesting, indexing, searching, and visualizing logs, metrics, and events at scale.
Flutter + Firebase Stack
Cross-platform mobile stack: Flutter builds one Dart codebase for iOS, Android, and web, backed by Firebase for auth, database, storage, and serverless functions.
React Native + Expo Stack
Cross-platform mobile stack using React Native with the Expo framework for managed builds, OTA updates, and native APIs from one JavaScript/TypeScript codebase.
Native iOS (Swift + SwiftUI)
Apple-native mobile stack building iOS apps with Swift and the declarative SwiftUI framework, using Xcode and first-party Apple platform frameworks.
Native Android (Kotlin + Compose)
Google-native mobile stack building Android apps with Kotlin and the declarative Jetpack Compose UI toolkit, using Android Studio and Jetpack libraries.
Kotlin Multiplatform (KMP)
Shared-logic cross-platform stack: Kotlin Multiplatform shares business logic across iOS, Android, and more, while UIs stay native or use Compose Multiplatform.
PLG Stack (Prometheus + Loki + Grafana)
Open-source observability stack: Prometheus collects metrics, Loki aggregates logs, and Grafana unifies visualization, dashboards, and alerting.
Elastic Observability Stack
Observability built on the Elastic Stack: Beats and APM agents feed Elasticsearch, with Kibana unifying logs, metrics, and traces in one platform.
GitOps Stack (ArgoCD + Terraform)
GitOps delivery: Terraform provisions infrastructure declaratively while ArgoCD continuously syncs Kubernetes application state from Git as the source of truth.
Grafana LGTM Stack
Grafana's full observability suite: Loki for logs, Grafana for visualization, Tempo for traces, and Mimir for metrics at scale, unified under OpenTelemetry.
OpenTelemetry + Tempo + Grafana Tracing Stack
Vendor-neutral distributed tracing: OpenTelemetry instruments and collects traces, Tempo stores them cheaply in object storage, and Grafana visualizes them.
HashiCorp Stack (Terraform + Vault + Consul + Nomad)
Cloud-agnostic infrastructure suite: Terraform provisions, Vault manages secrets, Consul handles service networking, and Nomad schedules workloads.
ClickHouse Real-Time Analytics Stack
High-performance analytics stack: ClickHouse ingests event streams from Kafka and serves sub-second OLAP queries powering user-facing dashboards.
Open Lakehouse Stack (Trino + Iceberg + dbt)
Open, engine-agnostic lakehouse: Iceberg tables on object storage, queried by Trino across sources, with dbt managing transformations in SQL.
LLM Agent Stack
Agentic AI stack: an orchestration framework drives an LLM to reason, call tools and APIs, and use vector memory to complete multi-step tasks autonomously.
Jaeger Distributed Tracing Stack
CNCF distributed tracing stack: OpenTelemetry instrumentation feeds Jaeger, which stores spans in Elasticsearch or Cassandra and visualizes request flows.
Vue + Laravel SPA
A Vue single-page frontend talking to a Laravel JSON API, a common PHP full-stack pairing for content-heavy and SaaS applications.
React + Spring Boot
A React frontend backed by a Java Spring Boot REST API, a workhorse enterprise stack for large, long-lived business applications.
Angular + Spring Boot
An Angular frontend over a Spring Boot Java backend, a strongly opinionated, fully typed enterprise stack favored by large IT organizations.
React + Django REST Framework
A React frontend consuming a Django REST Framework API, a productive Python full-stack for data-rich and ML-adjacent web applications.
SvelteKit + Postgres
A full-stack SvelteKit application with server routes and a PostgreSQL database, delivering fast, lightweight web apps with minimal JavaScript.
Express + React + Postgres
A classic JavaScript full stack: an Express REST API on Node.js, a React frontend, and a PostgreSQL database, flexible and widely understood.
Fastify + Prisma
A high-performance Node.js backend using Fastify with schema-based validation and Prisma ORM over PostgreSQL, built for low-overhead, type-safe APIs.
AdonisJS Full-Stack
An opinionated, batteries-included Node.js MVC framework with its own ORM, auth, and validation, bringing a Laravel-like experience to TypeScript.
Gatsby + Headless CMS
A React-based static site generator that sources content from a headless CMS and APIs through GraphQL, producing fast, pre-built marketing and content sites.
Eleventy + Netlify
A lightweight, zero-runtime static site generator paired with Netlify hosting and functions, producing simple, fast sites with minimal JavaScript.
Hugo + CDN
A Go-powered static site generator known for extremely fast builds, paired with a global CDN to serve large content sites cheaply and quickly.
Vapor Swift Server
A server-side Swift web framework using async/await and a typed ORM, letting iOS-focused teams build backends in the same language as their apps.
Vert.x Reactive Stack
A polyglot, event-driven toolkit on the JVM built around a non-blocking event loop and the reactor pattern for high-concurrency, low-latency services.
Play Framework (Scala)
A reactive, stateless web framework on the JVM written for Scala (and Java), built on Akka for non-blocking, high-throughput web applications and APIs.
Spring WebFlux Reactive
Spring's reactive, non-blocking web stack built on Project Reactor and Netty, for high-concurrency services that need backpressure and efficient resource use.
Ktor + Exposed
A lightweight, coroutine-based Kotlin web framework paired with the Exposed SQL library, for idiomatic, asynchronous Kotlin backends and APIs.
Rocket (Rust) Stack
An ergonomic, type-safe Rust web framework with compile-time route checking and request guards, paired with a database for fast, safe backends.
Axum + SQLx (Rust)
A modern async Rust backend built on the Tokio runtime with the Tower middleware ecosystem and compile-time-checked SQL via SQLx.
Symfony + API Platform
A robust PHP stack using the Symfony framework and API Platform to generate REST and GraphQL APIs from data models with documentation and standards built in.
ASP.NET MVC + EF Core
Microsoft's server-rendered web stack using ASP.NET Core MVC and Entity Framework Core over SQL Server or Postgres, for robust enterprise web applications.
FastAPI + HTMX
A modern Python stack pairing the async FastAPI framework with HTMX to build dynamic, server-rendered web apps with little custom JavaScript.
Gin + GORM
A fast, lightweight Go web stack pairing the Gin HTTP framework with the GORM ORM, popular for high-performance REST APIs and backend services.
Echo + Ent
A performant Go web stack combining the Echo framework with Ent, an entity framework that generates type-safe, graph-aware data access code from schemas.
Snowflake + Fivetran + Looker
A fully managed cloud analytics stack: Fivetran ingests data, Snowflake stores and transforms it, and Looker serves governed BI on top.
dbt + Amazon Redshift
An ELT analytics stack where data lands in Amazon Redshift and dbt transforms it with version-controlled, tested SQL models.
Databricks + Unity Catalog
A governed lakehouse stack centering Databricks compute and Delta Lake storage under Unity Catalog for unified data and AI governance.
Kafka + ksqlDB
A stream-processing stack using Apache Kafka for event transport and ksqlDB for SQL-based streaming transformations and materialized views.
Flink + Apache Paimon
A streaming lakehouse stack using Apache Flink for unified stream and batch processing over Apache Paimon's high-update table format.
Spark + Delta Lake
A lakehouse foundation pairing Apache Spark for distributed processing with Delta Lake's ACID table format over cloud object storage.
Trino + Iceberg + S3
An open lakehouse query stack: Trino runs fast SQL across Apache Iceberg tables stored as open files on Amazon S3.
ClickHouse + Grafana
A real-time analytics stack using ClickHouse as a fast columnar OLAP database with Grafana for dashboards over high-volume event data.
Apache Druid + Superset
A real-time OLAP stack using Apache Druid for sub-second slice-and-dice queries and Apache Superset for self-service exploration.
Apache Pinot Real-Time Analytics
A user-facing analytics stack built on Apache Pinot for ultra-low-latency, high-throughput queries over fresh streaming data.
Airbyte + dbt + Snowflake
An open-core ELT stack: Airbyte ingests data, Snowflake stores it, and dbt transforms it with tested, version-controlled SQL models.
Dagster + dbt
An asset-oriented data orchestration stack where Dagster schedules and observes pipelines built around dbt's transformation models.
Prefect + Spark
A Python-native orchestration stack where Prefect schedules and monitors large-scale data processing jobs running on Apache Spark.
Ray Distributed ML
A unified compute stack using Ray to scale Python machine learning workloads from data processing through training to serving.
vLLM + Ray Serve
A high-throughput LLM serving stack combining vLLM's optimized inference engine with Ray Serve for scalable, multi-replica deployment.
LangGraph + pgvector
An agentic LLM application stack using LangGraph for stateful agent workflows backed by Postgres with pgvector for retrieval and memory.
Haystack RAG
A production RAG stack built on the Haystack framework for composable retrieval-augmented generation pipelines over a document store.
LlamaIndex + Qdrant
A RAG and data-framework stack pairing LlamaIndex for LLM data ingestion and querying with Qdrant as a high-performance vector database.
Amazon Bedrock RAG
A managed RAG stack on AWS using Amazon Bedrock foundation models with Knowledge Bases for retrieval over data stored in S3.
Vertex AI Pipeline
A managed MLOps stack on Google Cloud using Vertex AI Pipelines to orchestrate training, evaluation, and deployment of ML models.
Amazon SageMaker MLOps
A managed MLOps stack on AWS using Amazon SageMaker to build, train, deploy, and monitor machine learning models end to end.
Triton Inference Server
A high-performance model-serving stack using NVIDIA Triton to serve models from any framework with GPU optimization on Kubernetes.
Tecton Feature Store
A production feature platform stack using Tecton to define, compute, and serve consistent ML features for training and real-time inference.
Kafka + Flink Streaming Lakehouse
An end-to-end streaming lakehouse stack: Kafka ingests events, Flink processes them in real time, and Iceberg tables on S3 serve analytics.
MosaicML Composer Training
A large-scale model training stack using Composer and the MosaicML toolkit to train and fine-tune models efficiently on GPU clusters.
Ionic + Capacitor
A cross-platform mobile stack that builds native iOS, Android, and web apps from a single web codebase using Ionic UI components and Capacitor native runtime.
NativeScript
An open-source framework for building truly native iOS and Android apps from a single JavaScript or TypeScript codebase with direct access to native APIs.
.NET MAUI
Microsoft's cross-platform framework for building native mobile and desktop apps for iOS, Android, macOS, and Windows from a single C# and XAML codebase.
Xamarin (Legacy)
Microsoft's earlier cross-platform mobile framework using C# and Xamarin.Forms, now superseded by .NET MAUI but still present in many maintained codebases.
Expo Router + Supabase
A full-stack mobile stack pairing React Native via Expo with file-based Expo Router navigation and Supabase for auth, Postgres, storage, and realtime.
Flutter + Riverpod
A cross-platform stack pairing Google's Flutter UI toolkit with the Riverpod state-management library for type-safe, testable Dart apps across mobile, web, and desktop.
SwiftUI + Combine
Apple's modern native stack pairing the declarative SwiftUI framework with the Combine reactive framework for building iOS, macOS, watchOS, and tvOS apps.
Compose Multiplatform
JetBrains' declarative UI framework built on Kotlin Multiplatform, sharing UI and logic across Android, iOS, desktop, and web from one Kotlin codebase.
Prometheus + Thanos
A scalable, highly available metrics stack extending Prometheus with Thanos for global query, long-term object-storage retention, and multi-cluster aggregation.
Datadog Full Platform
A unified commercial SaaS observability stack covering metrics, traces, logs, RUM, security, and infrastructure monitoring through Datadog agents and integrations.
New Relic Platform
A consumption-based SaaS observability platform unifying APM, infrastructure, logs, and browser monitoring on a single telemetry database with OpenTelemetry support.
Sentry + OpenTelemetry
An application monitoring stack pairing Sentry's error tracking and performance monitoring with OpenTelemetry instrumentation for vendor-neutral traces and metrics.
Jaeger + OpenTelemetry + Prometheus
An open-source observability stack combining OpenTelemetry instrumentation, Jaeger distributed tracing, and Prometheus metrics, visualized in Grafana.
Loki + Tempo + Mimir
Grafana Labs' scalable, object-storage-backed observability stack for logs (Loki), traces (Tempo), and metrics (Mimir), unified in Grafana.
Vault + Consul
A HashiCorp infrastructure stack pairing Vault for secrets management and dynamic credentials with Consul for service discovery, configuration, and service mesh.
Spinnaker Continuous Delivery
An open-source, multi-cloud continuous delivery platform for managing complex deployment pipelines with advanced strategies like canary, blue-green, and rollback.
Jenkins + Nexus
A self-hosted CI and artifact-management stack pairing Jenkins automation pipelines with Sonatype Nexus as a binary repository for builds and dependencies.
Tekton + Argo CD
A Kubernetes-native CI/CD stack pairing Tekton pipelines for in-cluster continuous integration with Argo CD for GitOps-based continuous delivery.
Cloudflare Workers + D1 + R2
A serverless edge stack running JavaScript at Cloudflare's edge with Workers, the D1 SQLite database, and R2 object storage for low-latency global apps.
Deno Deploy Edge
A serverless edge runtime stack built on Deno, running secure TypeScript and JavaScript globally with web-standard APIs and built-in KV storage.
Fastly Compute Edge
A high-performance edge computing stack running WebAssembly at Fastly's network for ultra-fast, secure serverless logic close to users.
Supabase Realtime Stack
A realtime application stack built on Supabase, streaming Postgres changes, broadcast messages, and presence to clients over WebSockets atop row-level security.
Firebase Realtime Stack
A serverless realtime app stack on Google Firebase using Cloud Firestore and the Realtime Database, with Auth, Cloud Functions, and offline sync for mobile and web.
Salesforce Platform
An enterprise low-code and pro-code application platform on Salesforce, using Apex, Lightning Web Components, and the data model to extend CRM and build business apps.
SAP BTP
SAP Business Technology Platform: an enterprise PaaS for extending and integrating SAP systems, building apps with the Cloud Application Programming model, Fiori, and integration services.