projects

Built a multitenant Dagster setup where multiple teams deploy to a shared instance instead of spinning up separate k8s deployments per team. Eliminates kubernetes overhead while letting teams work independently.

Key challenge: Dagster’s GraphQL layer requires globally unique assets. Solved with custom @asset wrapper that automatically adds tags and key_prefixes to everything. Single dagster.yaml lives in the main Helm release as a ConfigMap – code locations register themselves dynamically.

Game changer for workflows: teams can deploy different branches as separate releases in dev/qa and test in parallel. Before this, you had to merge with everyone else’s changes just to test anything. Blocking nightmare, now solved.

Greenfield teams onboard trivially (everything’s templated). Brownfield requires tweaks to ensure branch-based releases stay unique, but worth it.

Currently running two code locations in prod, second team onboarding soon. Open questions on scale limits – daemon and postgres load, UI filtering at high asset counts, missing RBAC for code locations (Dagster Cloud has this). But for now? Works great.

Built a proof of concept for self-serve analytics: ask questions in plain text, get back data insights without writing SQL. Uses Claude with MCP servers to query Iceberg tables directly via pyiceberg. Currently running on mock taxi data.

Technical flow: MCP server wraps pyiceberg with pre-configured query endpoints. Claude sees table schemas and metadata (Iceberg provides this cleanly), generates queries, returns results as HTML reports or markdown tables. Read-only by design – contributor access would unlock more use cases but opens up for malicious or accidental data changes.

The hard problems: trust and validation. Self-serve BI is only useful if the analysis is actually correct. For complex queries, Claude sometimes can’t bridge the semantic gaps or hallucinates when MCP capabilities fall short. Bad data in circulation is worse than no data. Table relationships are tricky at scale – larger datasets will need RAG or similar to handle cross-table semantics properly.

Next steps: Evidence integration for better report rendering, figuring out validation/transparency mechanisms, finding an approved use case to test in production. The tech works; the question is whether the output can be trusted enough to matter.

Built a proper dev onboarding experience that takes new developers from zero to productive in minutes instead of days. System-agnostic, reproducible, with secrets handled properly.

Stack: devenv manages packages and versions via nix (works across macOS/Linux/WSL identically), uv handles Python dependencies, pre-commit and commitizen enforce standards. SOPS encrypts secrets that live in the repo – no more “ask someone for the .env file” nonsense.

Onboarding flow: clone repo, generate an age key, make first commit. Someone with access updates the SOPS keys, and you’re done. All env vars sourced automatically when you cd into the directory (direnv), all packages scoped to that repo, zero global pollution.

Currently templatizing this. The goal: eliminate “works on my machine” and make developer experience actually good. If someone can go from git clone to running tests in under 10 minutes, it’s a win.

Built a complete NFT project from scratch: generative art system, smart contract, and web3 storefront. Trailer park theme with characters you’d actually find there – the plan was to build a whole universe on top, but hype/funding didn’t materialize.

Generated 10k unique images using weighted matrices across 13 attribute categories (120+ total traits). Wrote the smart contract in Solidity with reveal mechanics, bulk purchase discounts (more bought = cheaper per unit to cover gas), and royalties flowing to a shared community wallet. Integrated MetaMask, Coinbase Wallet, and Trust Wallet for ETH/WETH payments.

Launched right after Ethereum’s merge to proof-of-stake – gas prices were all over the place, made timing interesting. Sold out all 10k. Wasn’t a get-rich scheme (listed free, bulk buyers covered our hosting/gas), just wanted to build something fun and see if a community formed.

Biggest lessons: aligning a team around a shared vision, and learning tech with sparse documentation – lots of trial and error writing contracts, testing edge cases, breaking things until they worked.