← All work

Monetarium Explorer

Mar 2026 – present · Solo Frontend + de-facto Project & Architecture / Methodology Lead

  • Stimulus
  • Webpack
  • SCSS
  • Go templates
  • WebSockets
  • Vitest
  • Claude Code

Solo Frontend Developer and de-facto Project Manager / Architecture Lead on a three-person team adapting a 10-module, Go-backed block explorer (derived from Decred’s dcrdata) to the Monetarium multi-coin chain — a Decred-derived chain extended with a base coin (VAR) plus up to 255 SKA-type coins. I built two custom AI-agent skills and a Node automation tool to scale architectural analysis and GitHub project management, curated a 30+ document architectural wiki, and delivered the frontend adaptation for roughly a dozen page/feature specs.

This engagement is deliberately not a React project: the codebase keeps its existing stack (Go backend with a Webpack / SCSS / Stimulus / Go-templates frontend) and the multi-coin model is layered on with minimum disruption. It is cross-stack senior work in a blockchain / fintech domain, with AI-leveraged methodology as the through-line.

Engagement shape

  • Client: undisclosed.
  • Origin: direct contact / referral.
  • Structure: fixed-price contract; now running ~3 months and wrapping up.
  • Team: three people — me (frontend + project/architecture), a backend engineer (Blockchain + DevOps + Go + PostgreSQL), and a Product Owner.
  • Domain: a block explorer for the Monetarium blockchain.
  • Codebase origin: a standalone derivative of decred/dcrdata (Decred’s official explorer) — 10 separate Go modules plus a Webpack/SCSS frontend, treated as standalone with no upstream sync.

My role

The job title is “Frontend + Project Manager,” but the actual scope spans four roles:

  1. Solo Frontend Developer — adapted the existing UI to the multi-coin model, working in the legacy Webpack / SCSS / Stimulus frontend and Go HTML templates.
  2. De-facto Project Manager — introduced the team’s entire process scaffolding from a Telegram-only starting point, then ran the GitHub Project board, sprint planning, and issue triage.
  3. Architecture / Documentation Lead — designed and curated a 30+ document wiki: product specs, per-area data-flow traces, mutation-impact analyses, pattern catalogs, and a cross-domain constraint taxonomy.
  4. AI Tooling / Methodology Lead — built two custom AI-agent skills plus a Node automation tool that scale the above; these are portable artifacts, not project-only.

Tech stack

  • Frontend: Webpack, SCSS, Hotwired Stimulus (vanilla JS with conventions), Go HTML templates, and a WebSocket client in Stimulus controllers for live block / mempool / address updates. I introduced Vitest as the frontend test framework — the project had zero frontend tests before — and modernized a build/quality toolchain that was roughly six years stale (Webpack, plugins, linting, and formatting all brought up to current versions).
  • Backend (read and understood; not the primary contribution): Go 1.21+, PostgreSQL 13+, RPC integration with the chain node, across a 10-module Go workspace. I drove the migration of the backend WebSocket library to coder/websocket (replacing a deprecated dependency) via AI-assisted Go work — cross-stack ownership despite the backend being a colleague’s primary area.
  • Tooling I built (portable): a mutation-analyzer AI-agent skill (a five-mode state machine with a strict synthesis template and auto-chaining pipeline), a generate-tasks-json skill that drafts structured issues for a bulk-creation pipeline, and a Node script that consumes that JSON to create GitHub issues in bulk.

Selected work

Frontend multi-coin adaptation

Roughly a dozen page/feature specs, including:

  • Address page multi-coin rewrite — per-coin balance / received / spent, a coin selector and filter, a multi-coin CSV schema, a ?coin= URL contract via coin-context middleware, and BigInt balance accumulation in the chart pipeline.
  • SKA coin-supply charts — per-coin chart pipelines under one chart-ID namespace, big-integer cumulation, and an exact-precision legend (needed to avoid float64 precision loss for SKA’s 18 decimals).
  • Mempool page multi-coin — coin stats and derived fills, dual collection paths (batch and incremental), multi-saver fan-out, and atom-string arithmetic.
  • Block-details / blocks-list / homepage-metrics multi-coin adaptations.
  • /parameters page — treasury removal, the real 50/50 PoW/PoS split, an SKA coin-parameters section, and address-prefix corrections.
  • /attack-cost page — a VAR-only domain with manual hashrate / power / cost inputs replacing the hardcoded miner list.
  • /market page removal — no asset trades exist on this chain, so USD equivalents and background exchange polling were removed across home, transaction, address, and block views.

Legacy toolchain modernization

The Decred-derived codebase was ~6 years old when I joined, so the entire frontend build and quality toolchain was several major versions stale. I modernized it across the board — Webpack and its plugin set, linting, and formatting — with config rewrites where the new versions required them. This was prerequisite work for the multi-coin adaptation but stands on its own as a senior-IC contribution.

Frontend testing from zero

The project had no frontend tests at all when I joined. I introduced Vitest and wrote the initial unit suite over the parts of the multi-coin work most prone to regression: precision-sensitive arithmetic, coin-context middleware, and chart-pipeline transforms.

Process leadership

The project had just started when I joined — no task tracking, all communication over Telegram. Over the early weeks I introduced a GitHub Issues + Project Kanban board (later scaled via the generate-tasks-json skill and a bulk-creation script), daily standups, written specs as the anchor for decomposition, and agentic AI coding tooling, which is what enabled the custom-skills and automation work above.

Architecture & methodology

  • “Contract is the seam” decomposition. Every feature splits into one parent issue plus exactly two sub-issues — [DATA] (the backend producer delivers a contract shape) and [UI] (the frontend consumer renders against it). Both engineers agree on the contract once, then work in parallel.
  • Mutation-safety methodology. Project invariants are catalogued once and cross-linked from every code-area analysis rather than re-derived; the mutation-analyzer skill enforces this.
  • AI as an analysis multiplier, not a code-typer. I designed the methodology, the skill, and the policy framework; the AI executes under that spec. The leverage is in the methodology, not the output volume.