32 kept · hosted on claude.ai, linked from here

• Where Our Databases Live
  5 Oct
  Every Arkham database placed on the machines it actually runs on, as one picture you zoom into: a cluster grows into its machines, one machine into its shards, a Postgres instance into its disks, a Timescale service into its time chunks. A Today / Self-hosted switch moves each duty — backups, failover, upgrades, disk growth — across to our side, and shows what stays with Google either way.
• Database Building Blocks
  5 Oct
  The fifteen pieces that map is built from — a server, a VM sliced out of it, local and network disks, object storage, zones, the write-ahead log, backups, a standby, shards, a connection pooler, Kubernetes, and who runs which layer — with pictures you can break: kill a drive, a machine or a whole zone, or make a bad delete, and see which copies survive.
• Shortsmith v2
  24 Sep
  The shorts pipeline with a Now/v2 switch: topic queue, hook pick, script, voice, render, publish — and what v2 changes, with your own ideas as the source, a format chosen per idea and a thirty-second review before anything ships. Below it, the last twenty uploads as the channel sees them: one shape repeated, or many.
• Frontier Model Board
  24 Sep
  Every current model on one board, live rather than written down. Text laid out by region and by tier — frontier, workhorse, budget — with image, video and audio (speech-to-text, text-to-speech, live voice, music) on their own tabs. Search, a filter for what landed this week, and keyboard shortcuts.
• Guardrail Map
  24 Sep
  What actually stops a request, and where. One path from your app through the account check, the prompt classifier, the hidden system prompt, the model, the output check and the watermark — then a switch to a local open model that greys out everything the provider was doing. Send a normal request, an obviously bad one, an innocent one with a bad result, or one the model simply refuses, and watch where each stops.
• Sync Prep Board
  24 Sep
  A standup brief built from what actually moved: what to say, the questions each item is likely to draw and the answer to each, then the live work arcs with what shifted and what is still unsettled — every unsettled claim carrying where it came from. A relationship map between the arcs, computed from their dependencies rather than asserted.
• Cloudflare, In Front
  23 Sep
  One visit to a site that sits behind Cloudflare, all the way through: the name resolving to their address rather than the server's, the nearest of ~330 cities ending the connection, the four checks that run before the server knows a request exists, the verdict, and the second connection opened on your behalf. A switch stamps what is actually on at Arkham.
• Hypercore Chain & Machine
  23 Sep
  Two views of Hyperliquid. Left, the chain itself: pick an action — a deposit, a perp fill, funding, a spotSend — and watch which of an account's pockets move. Right, our machine for it: how cmd/chainetl turns those blocks into balances, trades and transfers, and what happens the first time it meets an address.
• Inside a Solana Block
  23 Sep
  One real transaction in slot 445,684,784, played a step at a time: 39 accounts, 6 instructions, a sale routed through three pools, and the receipt afterwards. The account tree shows who owns what and who may move it; the strip above shows confirmed trailing the tip and finalized trailing that by 32 slots.
• Harness Anatomy
  23 Sep
  One turn through Claude Code, with only one box in the picture that thinks. Pick what you type — a bug fix, /pr, a question about Gmail — and watch which files get pasted in front of the model, what the loop runs because the model asked, and what gets written down afterwards.
• Where a request lands
  9 Sep
  A request crossing Cloudflare and Google's load balancer into a single Go container — then what a node, a pod and a container actually are, drawn to the sizes they run at, with the private network shown as a line through shared machines rather than a box around them.
• Bits, bytes & keys
  9 Sep
  How wide a value can get decides its type everywhere — one log ruler from 1 to 10⁷⁸ with every type ceiling marked, and a value you slide along it to see which columns still hold it and which round it away in silence.
• Price feed wires
  9 Sep
  The same price event carried eight different ways — table, unary call, gRPC stream, websocket, framed TCP, webhook, broker log — and what each one can hand back after the consumer has been down for thirty seconds or three days.
• The gauntlet
  8 Sep
  One request falling through the whole auth and billing chain, read left to right like text — which gate can refuse it and with what status, who pays for it, and what the rate limits actually are per tier.
• Arkham — Pricing Pipeline
  7 Sep
  Eighteen feeds collapse every tick into one row per pair per venue per second, and a minute later one job folds those into a single weighted price — with the live BTC/USDT aggregate, the venue that quotes $101 high, and the trailing window venues age out of.
• StarRocks balances
  3 Sep
  A running simulation of the balance lane: blocks arrive, a batch freezes on whichever limit trips first, and one transaction lands the facts. Rebuild a generation and watch it catch up in the dark, then swap the pointer.
• Txindex call tree
  1 Sep
  Every function in the txindex PR and who calls whom — click one to trace it, open a call into its own tree, and read from the connector shape whether it fires once, per item, or behind a guard.
• Six blocks becoming an index
  1 Sep
  Fifteen steps from six raw blocks to a searchable index, each naming the file that does the work, with the bucket beside it filling up and then being tidied and swept.
• Where the venues disagree
  1 Sep
  An exchange says where its tokens are credited; most of it becomes a line and some is thrown away, and whatever ends up connected is one asset — stepped through claim by claim, rejections included.
• One name per asset
  30 Aug
  Why the vendor's table cannot hold two contracts of one token on one chain, how twelve names fold into a single asset, and the three tables that keep that answer so a price can be stored against it.
• Hash to block
  29 Aug
  An index over the block archive with no database in it: forty-byte records, segments cut one way and base shards the other, and a coverage grid you drive to watch compaction fold one into the other.
• Car cutaway
  29 Aug
  A running car you drive with throttle, brake, gear and steering — click any part for what it does and what holds it on, then open it into its own working mechanism.
• Finding one transaction in four billion
  28 Aug
  How the index gets built, what one lookup actually costs — watch it halve the search until it reads a few hundred bytes — and the 65,536-drawer grid showing why new work waits in a side pile.
• Naming every asset
  26 Aug
  What happens to the three tables that decide a token's name — a new mint, a first listing, a second venue, and the rare case where two assets turn out to be one. A second view shows the missing hop into StarRocks, and the two different things both called asset_id.
• Chain Ingestion Pipelines
  25 Aug
  One block falling through every stage, drawn as a tree — pick a chain family and it keeps its shape while the names change. Click a queue for its real schema, a stage for the read window its cursor and gates give it. Separate views for what a reorg actually does, and for the archive rebuild that runs on the other clock.
• Where one price comes from
  25 Aug
  Eight steps from a venue tick to a dollar figure — five rows in three different naming systems, aggregated, folded into one asset, then priced by multiplying outward from the stablecoins. Ends on the read nothing has been built for yet.
• One minute, in dollars
  25 Aug
  One minute's pricing pass, call by call: the eight functions it makes, the 728 ticker mappings it refuses rather than guess at, and the wrapped-SOL row that keeps a gas balance reachable at all. The engine and its harness exist; the job that would run it does not.
• What a token is, said three ways
  24 Aug
  Three tables that record what each source claims a token is, keyed so a ticker means something only inside one venue — with the contradictions they refuse rather than resolve.
• Two databases and the gap between
  24 Aug
  Which tables sit in pricingdb, which in StarRocks, and the pure library between them — open any two side by side and the shared columns light up, or nothing does.
• Which database? Walk the tree.
  12 Aug
  One question at a time, from what you are storing down to a named database — with twelve real workloads walked through it, and each answer ruling out the places it kills.
• The District Map of London
  10 Aug
  Where the names on the tube map actually sit, and what they are names of.
• Arkham API — Data Provenance
  29 Jul
  Each API endpoint against the stores that actually answer it — read from, joined against, served out — and whether the answer is computed on request or ahead of time.