Using Postgres as a Data Warehouse - Start with Postgres 18+ — asynchronous I/O makes table scans 2-3x faster than Postgres 15 - One command runs everything: `docker-compose up`. If partitioning breaks on localhost, it'll break in prod — test the real structure first - Async I/O in Postgres 18 changes everything — sequential scans that took 45 seconds now take 15 - No config changes needed — it just works faster out of the box - Postgres isn't just storage — it's your transform layer, your cache, your query engine - Materialized views = dashboards that don't run live queries when 500 people open Slack at 9 AM - Partition by date or tenant — keeps queries under 3 seconds without bigger hardware - VACUUM and ANALYZE aren't optional - Use schemas like folders — `raw` for ingestion, `staging` for transforms, `analytics` for BI - JSONB feels flexible until you try to aggregate Millions rows — use real columns for anything you'll query often - Foreign keys and constraints catch bad data before your dashboard does - DuckDB reads Postgres tables directly — `duckdb 'SELECT * FROM postgres_scan(...)'` - Run heavy aggregations in DuckDB, write results back to Postgres — best of both worlds - Postgres 18's async I/O + DuckDB's columnar engine = the fastest local analytics stack nobody talks about - Indexes win 90% of performance battles — btree for filters, GIN for arrays, BRIN for time-series logs - `EXPLAIN ANALYZE` until you understand how Postgres thinks — if it scans 5M rows, add an index - Async I/O helps, but indexes help more — fix the query plan before throwing hardware at it - Backup is boring by design: `pg_dump` to S3 every night - Back up schemas separately from data — schema recovery is 10x faster than full restores - Postgres 18's faster I/O means backups and restores complete in half the time - The real test: can a new engineer clone your repo, run `docker-compose up`, and query prod-like data in 5 minutes? - Postgres 18 is the warehouse you already have — just use it properly

Been playing with Jev this week. My first thought was a Bloom filter: a fast cheap check before the expensive work. It's not the same though. A Bloom filter gives a hard guarantee; Jev gives a confidence score. So I stopped comparing and started testing. I work on real-world oncology data. Our AI agent plans and runs analyses on Datawarehouse, and the big model burns a lot of time on small calls. Simple count or survival analysis? Ask the user or work it out? Days or months? Did I actually answer the question? That's exactly Jev's territory. So I'm testing it on routing, ask-or-act, and plan checks. The big model keeps the reasoning, and all data access rules stay deterministic. The real question is whether the confidence holds up on clinical data.

I recently started working with a well-known healthcare data vendor. They need at least 2 weeks to set up the aws infrastructure—before they can even begin copying the data to S3. AI may be taking some jobs, but certain traditions remain untouchable. It’s strangely comforting to feel frustrated again. I finally feel like a software engineer.

My @OpenAI API key was somehow compromised, and I became curious: what could someone actually do with a stolen key? The logs led to me the project named Stratum—a genuinely intelligent Rust project aimed at the Docker ecosystem, used gpt-6-astra (ofcourse) Most secret scanners inspect small configuration files. Stratum targets the large 20–500 MB Docker image layers that people rarely unpack and inspect—yet may contain 5–6× more exposed credentials. The engineering is impressive: - Streaming image-layer downloads - RocksDB with column families and prefix-range scans - Snappy and Zstd compression - Cryptographic validation for BIP39, secp256k1, Base58Check, and CRC16 - JWT classification, entropy checks, and placeholder deny-lists - Content-addressed caching to reuse findings across images It does not stop at finding secrets. It can live-test exposed OpenAI and Anthropic keys, read OpenRouter credits, derive wallets from leaked private keys, and check balances across seven blockchains. It even uses a pool of Docker accounts to work around rate limits and scan roughly 700,000 layers per day. Beautiful engineering—but essentially a high-performance loot scanner. 🔥 Now I need to figure out how my key was compromised in the first place! 😅

Link github github.com/firecrawl/pdf-ins…

First Claude went down, so I switched to Codex. Then Codex went down too. 😅

Claude is back to basics and down again!

I wanted to see how far a small open-weight model can go on regulated data workflows if I give it skills instead of moving to a bigger model. Setup: 27B dense model at Q6, 2 consumer GPUs, fully local, no fine-tuning. 5 SKILL md files: cohort specs, value sets, index/washout logic, bias review, ledger classification. Constrained JSON output. Every code, count and number comes from a tool call, not from the model. I have not tested it deeply yet. But what I saw is good enough to keep going. Most of the improvement seems to come from the skill and context layer. The main problem so far is the wrong skill getting loaded. I think adding skills might be enough for a lot of these tasks. Worth trying before moving to a bigger model.

So technically, @duckdb is joining AWS… and now I’m genuinely not sure how to react 😅

Had Claude Code run Codex as an independent reviewer. Read-only sandbox, full session log — every command it ran, replayable after the fact. Good: I can prove exactly what it looked at. Less good: that proves provenance, not correctness. Still had to verify the findings myself.

Claude CLI remote control complexity is almost zero — one command and it mostly just works. Comparatively Codex remote control feels very old-school Windows Vista 😅 Too many steps around start, pair, connect, and you still don’t really know if it will work this time or not. For something like remote control, I would prefer much less process and much more predictability.

I am extremely impressed by Qwen-3.8 for Agentic Coding, so I am setting up a GPU System for Local LLMs — and somehow that has become one of my core reasons to travel to India - 2× used RTX 3090 24GB. They are way cheaper in India, and if I really need more VRAM I can add a second one later. - Ryzen 5600 + AM4 + 64GB DDR4 is cheaper in Germany. - Will still size the motherboard + PSU for 2×3090, so upgrading later is easy. - Energy cost is way cheaper in India, even after considering air conditioning. For remote access, I will use an encrypted WireGuard/Tailscale tunnel. Upload speed from India is also not that bad, and I have already tested the same setup with my 3060 sitting there — network was honestly not the biggest hurdle. Currently my 2013 Mac running Linux handles the GPU server remotely, and I hope to continue using it as the little management box 😅 Might also add PiKVM + UPS, because debugging a GPU server from 6,500 km away is probably where things get interesting.

Link chromewebstore.google.com/de…

Read a scaling-law post today and finally got a frame that stuck. Think of a model like a student. You can grow the brain, hand them more books, give them longer per question, or put them with a tutor. Brain size is shelf space. It's how much the student holds, not how many steps of reasoning they carry before losing the thread. Dense models blurred those together. MoE splits them into separate numbers. Then economics. The student doesn't sit one exam, they sit millions and you pay every time. That's why the open-weight releases keep training small models way past the point that looks sensible. Expensive once, cheap forever after. And the recent ones make the last dial obvious. Same base, same architecture, same parameter count as the previous version. More post-training. Real gains. Scaling AI Models has multiple dials. They don't have to move together.

Claude is down again, and it’s happening way too often

I had to run an LLM over a lot of clinical notes. Sensitive data, so hosted APIs were out. Local model, our own GPUs. The model part was easy. Sharing GPUs was the annoying part. A few teams use the same machines, everyone seems to start around 9am, and one bad run can easily block someone else's fine-tune. I looked at Ray, Kubernetes, even thought about putting together a small Celery + Redis queue. Then someone suggested Slurm. I always thought of Slurm as an HPC/university cluster thing, but it actually fits this problem really well. slurm.schedmd.com/overview.h… You submit a job, say what resources you need, and Slurm handles who gets what and when. The nicest surprise was sacct. It already keeps a history of the jobs that ran. So when QA asked who ran what, where, for which study, and whether it completed, most of that was already there. No need to build another tracking system around it. You can also keep sensitive workloads on specific nodes using partitions, and run hooks before/after jobs for mounting, cleanup, GPU reset, etc. Slurm was quite new to me, so I can't really compare it with Ray yet. I also think they solve slightly different problems. But for this shared GPU setup, I really liked Slurm. Much more useful than I expected.

If you're building anything that touches HIPAA or sensitive data, look at Presidio: github.com/microsoft/presidi… You feed it text, it finds the identifiers and swaps them for tokens, and keeps the mapping on your side. Find PHI, replace, re-identify later — the whole machine in one library. I tried the DIY route first — regex plus spaCy NER. It works, but it leaks. Presidio packages the same approach with context rules and custom recognizers on top, and the leakage drops noticeably.