Skip to content
All categories

tech

518 posts

Django: Python Web Applications with ORM, Admin, Auth, and Long-Term Evolution

Django combines data models, migrations, authentication, admin, forms, and security defaults into one system; using it well still requires understanding QuerySets, middleware, async boundaries, and production settings.

Dokku: Turning One Docker Host into a Git-Push PaaS

Dokku combines a Git receiver, buildpacks or Dockerfiles, process models, Nginx, and plugins for a single-host Heroku workflow; simplicity comes from narrow orchestration scope.

Dokploy: Self-Hosted PaaS with Applications, Compose, Remote Servers, and Swarm

Dokploy supports single-container Applications and Compose or Stack, while treating one host, independent remote servers, and a Swarm cluster as distinct topologies.

DuckDB: An OLAP Query Engine Inside Your Process

DuckDB is an in-process columnar OLAP database for Parquet, CSV, and DataFrames, not a conventional multi-user OLTP server for web applications.

techdeep-dive

Elasticsearch and OpenSearch: Choosing a Lucene-Based Site Search Engine

Elasticsearch and OpenSearch both build text analysis, BM25, aggregations, and vector search on Lucene, but licensing, governance, hybrid-search APIs, and managed ecosystems have followed separate paths since the 2021 fork.

Elysia: Bun-First APIs with Runtime Schemas and End-to-End Types

Elysia connects runtime schemas, TypeScript inference, OpenAPI, and Eden clients into one contract pipeline, but Bun-first performance, plugin scope, and cross-runtime compatibility still require separate verification.

Fastify: Plugin Encapsulation, JSON Schema, and Efficient Node.js APIs

Fastify is more than benchmarks: plugin scopes, hooks, decorators, and compiled JSON Schema build composable Node.js APIs with explicit request and response contracts.

Firebase: The BaaS Boundary of Auth, Firestore, Functions, and Security Rules

Firebase moves quickly because client SDKs directly access managed Auth, Firestore, and Storage; the real backend contract lives in data models, Security Rules, Functions, and cost limits.

Fly.io: The Real Boundaries of Machines, Fly Proxy, and Multi-Region Deployment

Fly.io places fast-starting Machines in chosen regions and connects them through Fly Proxy and private 6PN; cross-region state consistency remains your hard problem.

gitleaks: Secret Detection across Working Trees, Git History, and CI Diffs

gitleaks scans files or Git patches with rules, regexes, entropy, and allowlists; after a finding, revoke and rotate first rather than merely deleting a file or rewriting history.

Google Cloud Model Armor: Runtime Filters around Prompts, Responses, and Agent Tools

Model Armor can inspect prompt injection, jailbreaks, sensitive data, malicious URLs, and unsafe content at runtime; it is a probabilistic detector, not an authorization or sandbox boundary.

Google Cloud Run: Services, Jobs, and Worker Pools Have Different Container Lifecycles

Cloud Run is more than an HTTP container platform: choose request-serving, run-to-completion, or always-on pull work first, then design concurrency, identity, and scaling.

Google Kubernetes Engine: GKE Autopilot Reduces Node Operations, Not Kubernetes

GKE manages the Kubernetes control plane and Autopilot manages most node infrastructure, while workloads, policy, networking, upgrade compatibility, and cost governance remain yours.

GraphQL and Code Generator: Type Safety Comes from Schema Plus Operations

A GraphQL schema defines available capabilities; GraphQL Code Generator combines it with actual queries, mutations, and fragments to emit precise results, variables, and typed documents.

gRPC and Connect: One Protobuf Contract across Services and Browsers

gRPC generates cross-language stubs from Protobuf services. A Connect server can support gRPC, gRPC-Web, and the Connect protocol together, avoiding a translating proxy for browsers.

Hatchet: One Engine for Task Queues, DAGs, and Durable Tasks

Hatchet unifies regular tasks, DAGs, and durable tasks behind a Postgres-backed control plane. Durable tasks checkpoint at waits and child tasks, then replay deterministic orchestration code on recovery.

Hetzner Cloud: Cheap VMs Mean Owning the Entire Operating System

Hetzner Cloud offers lean IaaS through servers, networks, volumes, load balancers, and firewalls; its price advantage is real only after patches, HA, backups, egress, and on-call are counted.

Hono RPC: Infer Fetch Client Types from Route Implementations

Hono RPC exports a route's `typeof AppType` so `hc` can infer inputs, response bodies, and status codes. The shared artifact is a TypeScript type, not an independent wire schema.

Inngest: Turn Serverless Functions into Recoverable Workflows with Steps

Inngest makes steps the persistence boundary for ordinary TypeScript, Python, and Go functions. Recovery re-executes the function while memoized steps avoid repeating completed side effects.

Kamal: Docker Deployment Without a Resident Control Plane

Kamal deploys immutable images from an operator over SSH and switches traffic through kamal-proxy; it is not a scheduler and does not operate hosts or data.