Monetarium Explorer

Full-Stack Feature Developer and Project Manager / Architecture-Analysis 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 shipped 150+ merged PRs of multi-coin feature work end-to-end (Go backend through the frontend).

Live: monetarium.online (mainnet) · testnet.monetarium.online (testnet)

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-analysis), 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. Full-stack Feature Developer — delivered 30+ features end-to-end (150+ merged PRs) as vertical slices, from the Go backend data layer through the legacy Webpack / SCSS / Stimulus frontend and Go HTML templates (AI-assisted). The team ran no strict frontend/backend ownership — one full-stack issue per PR, split by change, not layer.
2. 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-Analysis / Documentation Lead — reverse-engineered the inherited (dcrdata-derived) architecture and curated a 30+ document wiki: 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, uPlot for the chart pipelines, 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 (Go, AI-assisted): Go 1.21+, PostgreSQL 13+, RPC integration with the chain node, across a 10-module Go workspace. Most multi-coin features shipped as full-stack issues — I implemented the Go backend side (data layer, coin-context middleware, collection / saver paths) and the frontend for each in one vertical slice — and I drove the migration of the backend WebSocket library to coder/websocket (replacing a deprecated dependency). The second engineer’s primary area was blockchain / DevOps; feature delivery was full-stack and not split by layer.
• 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 areas (30+ merged feature PRs), 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

• From “contract is the seam” to full-stack issues. Early on, each feature split into [DATA] (backend producer) and [UI] (frontend consumer) halves so the two engineers could agree the contract once and build in parallel. As the team settled into AI-assisted, per-developer end-to-end delivery, this evolved into one full-stack issue per PR — split by what the change is, never by layer, with a domain prefix ([ADDRESS], [MEMPOOL], …) marking the area. Large features still decompose, but into vertical slices (each its own one-PR full-stack unit), not backend / frontend pairs.
• 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.