Technology decisions, compared.

htmx pushes HTML over the wire and lets the server do the thinking. React owns the client, ships JS, and treats the DOM as an output of state. The honest split is workload, not taste.

All three install JS packages. The difference is disk, install speed, monorepo behaviour, and how often the lockfile betrays you. Yarn 4 caught up. npm caught up partially. pnpm still leads on the things engineers feel.

Both can hold money. TigerBeetle is a single-purpose ledger database that does double-entry accounting, deterministic state machines, and 1M+ transfers per second on commodity hardware. Postgres is a relational generalist. The pick is honesty about what you actually need.

Three OLAP engines for three jobs. ClickHouse for high-concurrency, low-latency dashboards on huge tables. DuckDB for embedded, single-process analytics next to your app or notebook. Snowflake for the warehouse with the credit card and the org chart.

All three describe cloud as code. The split is the language and the audience. Terraform / OpenTofu use HCL and a state file. Pulumi lets you write infrastructure in TS, Python, Go. AWS CDK targets AWS exclusively and synthesises CloudFormation.

All three terminate TLS and forward traffic. The split is operating model: Caddy is opinionated single-binary with automatic HTTPS, nginx is the industrial workhorse, Traefik is Kubernetes / Docker-native with dynamic config from labels.

Both speak TypeScript fluently now. The split is philosophy: Drizzle is a thin SQL builder that vanishes at compile time, Prisma is a managed ORM with a generated client and a query engine.

A year ago Bun was promising, Node was the safe default, Deno was the principled outsider. In 2026 all three are shippable in production, but they win different problems.

The agent-tooling layer finally settled into three jobs: skills (instructions + assets the model loads on demand), MCP (a portable protocol for tools and data), and agent frameworks (the loop that actually runs).

For three years vitest was the obvious answer. In 2026 the built-in runners (bun test, node:test) are good enough that the choice is no longer reflex.

Three providers, three pricing shapes. Upstash bills per request and runs on edge POPs, Redis Cloud bills per provisioned instance, Dragonfly is wire-compatible Redis with multi-threaded internals at a third of the cost.

For a Hungary-incorporated SaaS the billing stack splits on three axes: NAV-compliant invoicing, payment UX, and who carries the tax burden across markets.

Both are mature. Both ship. The choice comes down to team composition, native surface, and design system.

Two great frameworks, different shapes. Next.js is a React-first full-stack app framework. Astro is a content-first static generator with React/Vue/Svelte islands.

This is really a chain choice. Solidity means EVM (Ethereum + L2s + sidechains). Rust is primarily Solana · plus NEAR and Cosmos variants. Pick the chain, the language follows.

Both can sell online. For a Hungary-first webshop with HUF billing and local delivery integrations, the economics differ sharply.

In 2026 Postgres is the default SaaS DB unless you have a specific reason to pick otherwise. Here's when each makes sense.

All three host Next.js / SvelteKit / Astro sites. The differences show up in pricing, edge performance, and how you ship serverless logic.

All three are production-grade. Picking one depends on latency, cost, reasoning depth, and what non-obvious guardrail behaviour you want.

Pre-built auth saves you 2-4 weeks vs rolling your own. The three serious options in 2026 differ on pricing, DX, and how far they scale into enterprise.

Self-handling tax is a job. Merchant-of-Record (MoR) providers take it off your plate for a higher fee. Here's when each trade-off works.

Go direct to the vendor or route through an aggregator? It's mostly a question of ops maturity, fallback strategy, and how much model-switching agility you actually need.

Hyperscalers offer every primitive. European clouds offer 1/3 the price for 80% of the use cases. For a bootstrapped or EU-native SaaS, the math matters.

CI runs every push. Choose by scale, DX, and how much you want to own runner infra.

2026 verdict: Tailwind won the app-UI fight for most teams. But nuance remains - design-system teams and marketing sites still benefit from scoped CSS.

Knowledge base, product tracker, or enterprise process tool · each wins a different job. Mixing them is normal; overlap creates friction.

Logs + metrics + traces. Three camps · the all-in-one (Datadog), the open-source-friendly (Grafana), and the distributed-traces specialist (Honeycomb).

Rust for embedded has arrived. When it's safe to pick, when C still wins.

Different problems · Kafka for event streams, RabbitMQ for work queues, NATS for low-latency fanout.

ESP32 is the default for Wi-Fi / BLE IoT. STM32 wins on low-power + motor control. Pi when you need a full OS.

Playwright has become the de-facto E2E. Cypress still wins in specific DX niches. Vitest Browser is the new entrant worth tracking.

All three ship real content. Sanity wins on DX + structured content. Strapi for self-host + open source. Contentful for enterprise procurement.

REST + OpenAPI for external APIs. tRPC for TypeScript-only monorepos. GraphQL when you actually need flexible clients.

Three serverless DBs, three mental models. Neon for Postgres-native, Turso for edge-first SQLite, PlanetScale for MySQL + heavy branching.

Vitest is the new default. Jest still fits legacy codebases. Deno.test when you're already on Deno.

Sentry dominates · Rollbar and Bugsnag still fit specific shapes. Datadog bundles it if you're already there.

Three billing paths for an indie SaaS. MoR simplicity vs full control.

Shopify wins on speed-to-market for international shops. Custom (Next.js + Medusa) wins for Hungarian shops needing tight NAV / SimplePay / Foxpost integrations and full control over taxes, locales, and seasonal stock logic.

WordPress wins on launch speed and content-team familiarity. Custom (Next.js / Astro) wins on speed, SEO, security, and total cost of ownership beyond year 2.

One lives inside the Postgres you already run; the other is a managed vector database you pay for separately. The choice is mostly about scale and operational appetite.

Both connect your apps and automate the busywork. One you can self-host and own; the other is a polished SaaS you rent. The split is about control and data residency.

Passkeys are phishing-resistant credentials bound to the device; passwords are the thing every user already understands. The right call depends on your audience and how much migration friction you can absorb.

Fine-tuning bakes new behaviour into the model's weights; RAG feeds the model fresh facts at query time. They solve different problems - and most teams reach for the wrong one first.

SimplePay (OTP) is the Hungarian default - local cards, local trust, NAV-friendly. Stripe is the global standard with the better developer experience. For a HU-market shop the answer is rarely as obvious as it looks.

Polling asks "anything new?" on a timer; a webhook gets pushed the moment something happens. The choice shapes latency, server load, and how much you trust the other side's reliability.