Scheduled infrastructure shutdown · November 21, 2026 Read the service update

INDEPENDENT ENGINEER · G4MM4

From bare metal
to the browser.

I build the infrastructure, data pipelines and interfaces that turn complex systems into useful products.

My work spans public blockchain services, validator analytics, desktop node tooling and the automation that keeps it all running. I’m ready to bring that range to a new team.

Available for consulting, contract, part-time & full-time work

G4MM4 SCAN PUBLIC APPLICATION
G4MM4 Scan showing mainnet and testnet network statistics
PULSE NODE MANAGER DEV PREVIEW
Pulse Node Manager desktop interface, development preview with fixture values
DESIGNED. BUILT. OPERATED.
InfrastructureSystems engineeringData platforms Full-stack productsDevOps & reliability

SELECTED ENGINEERING WORK

Built to do real work.

Applications people could use.
Systems I could operate.
Details you can inspect.

11 projects shown
G4MM4 Scan network dashboard with validator and chain activity panelsEnlarge screenshot

Public application capture · November 20, 2026. Historical network data.

Analytics · Full stack

ValDash / G4MM4 Scan

Making a proof-of-stake network legible.

A validator analytics platform connecting execution and consensus data to network overviews, validator income, proposals, epochs, slots and transactions.

  • JavaScript
  • Node.js
  • SQLite
  • Ansible
Engineering details

My contribution

Built the collectors, durable cursors, SQLite data layer, Express APIs and browser interface. Added reorg tracking, income reconciliation and rolling deployment.

The engineering decision

A successful HTTP response is not enough. Chain data can arrive late, change during a reorg or disagree across sources. Collection and reconciliation make those states visible instead of presenting uncertain data as settled.

G4MM4 Scan epoch visualization, chain activity charts and recent blocksEnlarge screenshot

Public application detail · November 20, 2026. Historical activity.

Public application · retirement scheduled November 21, 2026

Source locations

  • valdash/server/lib/single-flight.js
  • valdash/server/
  • valdash/ansible/
Pulse Node Manager desktop development preview in dark modeEnlarge screenshot

Desktop development preview · October 2026. Fixture values, not a live node.

Desktop · Systems

Pulse Node Manager

A node operator’s control room.

A Rust supervisor with CLI, local dashboard and Tauri desktop interface for running execution and consensus clients together.

  • Rust
  • Tauri
  • TypeScript
  • Docker
Engineering details

My contribution

Built lifecycle control, resource preflight, network isolation, signed runtime profiles, readiness checks and a journaled update workflow with explicit recovery.

The engineering decision

An interrupted update must leave a recoverable operation, not an ambiguous installation. Recovery is required before a conflicting operation can begin.

Public pre-preview · platform qualification in progress

Source locations

  • PulseNodeManager/crates/pns-core/src/update_transaction_recovery.rs
  • PulseNodeManager/crates/pns-core/src/health.rs
Ludicrously Sound Money supply dashboard and historical supply chartEnlarge screenshot

Public application capture · November 20, 2026. Historical supply data.

Data visualization · Web

Ludicrously Sound Money

Supply economics, made visible.

A dashboard explaining PLS supply through issuance, burns, staking and historical trends, with readable charts and a responsive interface.

  • JavaScript
  • Express
  • Charting
  • Caching
Engineering details

My contribution

Built the dashboard and Express cache/proxy layer, batched history requests and shared in-flight fetching to avoid duplicate upstream work.

The engineering decision

Historical charts should stay responsive without repeatedly requesting the same block. Cached results and shared promises reduce redundant requests.

Public application · retirement scheduled November 21, 2026

Source locations

  • LudicrouslySoundMoney/server.js
  • LudicrouslySoundMoney/index.html
PLS Supply API interactive OpenAPI documentationEnlarge screenshot

Public API documentation capture · November 20, 2026.

Indexing · API engineering

PLS Supply API

Accounting from chain data to API.

An indexing pipeline and documented API combining protocol issuance, burns, burn-address balances, deposits and beacon staking balances.

  • Python
  • FastAPI
  • PostgreSQL
  • OpenAPI
Engineering details

My contribution

Built Python processing, PostgreSQL persistence, finality-aware slot mapping and FastAPI endpoints for current supply, block history and time series.

The engineering decision

Execution blocks and consensus slots are different timelines. Mapping stops at the finalized slot and retries when finality cannot be established.

Implemented API and indexer · retirement scheduled November 21, 2026

Source locations

  • pls-api-com/app/slot_mapper.py
  • pls-api-com/app/supply_processor.py
  • pls-api-com/app/api.py

Reliability · Public infrastructure

Public RPC & node operations

Health means moving forward.

Public PulseChain execution and beacon APIs, checkpoint and snapshot services, plus Ethereum execution RPC.

  • Python
  • Ansible
  • Nginx
  • Terraform
Engineering details

My contribution

Built infrastructure automation and operational safeguards around upstream clients, including head-progress watchdogs, unhealthy-origin draining and maintenance ownership checks.

The engineering decision

A node may answer requests while no longer advancing. The watchdog checks both execution progress and consensus-boundary progress before declaring a stall.

Operated public infrastructure · retirement scheduled November 21, 2026

Source locations

  • tf-pulsechain/ansible/playbooks/common/nodes/rpc/stall_watchdog.py

DevOps · Delivery engineering

Infrastructure & release automation

From source to an operable system.

Terraform provisioning, Ansible convergence, containerized services, persistent storage and repeatable release workflows.

  • Terraform
  • Ansible
  • GitLab CI
  • Docker
Engineering details

My contribution

Built versioned deployment and rollback tooling, HTTPS release delivery, GitLab provenance verification and downstream desktop qualification orchestration. Integrated controlled builds for owned execution/consensus client forks.

The engineering decision

Building an artifact and qualifying an installed application are separate jobs. Delivery tooling preserves artifact identity across that boundary.

Implemented tooling · final desktop qualification remained open

Source locations

  • PulseNodeManagerDeploy/
  • PulseNodeManager/client-builds/
  • tf-hetzner/ansible/

Indexing · Platform integration

Graph Node infrastructure

Queryable data with observable freshness.

Deployment and operation of upstream Graph Node with PostgreSQL, IPFS, persistent storage, HTTPS and subgraph deployment automation.

  • GraphQL
  • PostgreSQL
  • IPFS
  • Python
Engineering details

My contribution

Integrated the stack and built semantic health checks around subgraph progress, chain lag and frozen heads for DEX and protocol datasets.

The engineering decision

An index marked “synced” can still lag behind the chain. Health considers both lag and the time since the indexed head last advanced.

Implemented upstream integration and operational tooling

Source locations

  • tf-hetzner/projects/graph/health_sidecar.py
  • tf-hetzner/projects/graph/docker-compose.yml

Historical work · Streaming data

Firehose & Substreams

Composable blockchain data pipelines.

Historical integration work around upstream Firehose and Substreams for blockchain streaming and DEX indexing.

  • Rust
  • WebAssembly
  • Substreams
  • PostgreSQL
Engineering details

My contribution

Built Rust/WASM indexing modules, separated stable DEX stores from faster-changing pricing modules and emitted database changes for a PostgreSQL sink.

The engineering decision

Separate reusable chain extraction from application-specific transformations so pricing changes do not require redesigning every indexing stage.

Historical implementation · removed from later platform scope

Source locations

  • tf-hetzner/projects/dextrace/substreams/pulsechain/src/
  • tf-hetzner/projects/dextrace/substreams/dextrace/src/lib.rs

Observability · Operations

Fleet observability

One view across many failure modes.

A shared monitoring plane for application status, endpoint availability, chain lag, structured logs, alerting and backup visibility.

  • Prometheus
  • Grafana
  • Loki
  • Node.js
Engineering details

My contribution

Designed Prometheus/Grafana/Loki integration, service dashboards and a custom administration API with semantic service status.

The engineering decision

Process uptime and data readiness answer different questions. Operators need to see degraded, syncing and unavailable states with their context.

Implemented components · no current fleet-health claim

Source locations

  • tf-hetzner/projects/monitoring/admin-api/
  • tf-hetzner/projects/monitoring/README.md

Linux · Storage automation

Bare-metal storage tooling

Operational work deserves good tools.

Rescue-mode utilities for NVMe RAID setup and expansion, with root/data disk separation, phase resume and cleanup.

  • Bash
  • Linux
  • NVMe
  • RAID
Engineering details

My contribution

Built reusable shell tooling and operator documentation for storage workflows, including dry-run previews before consequential changes.

The engineering decision

Disk operations need explicit targets and recoverable phases. Make the intended work visible before a tool changes storage.

Implemented operations tooling

Source locations

  • scripts/hetzner/raid0-data-dir.sh
  • scripts/hetzner/raid0-expand.sh
Historical base-fee chart reconstructed from archive block headersEnlarge screenshot

Historical reconstruction · December 25–26, 2023; CET time, logarithmic fee scale.

Research · Chain forensics

Historical gas-fee investigation

Reconstruct the data. Explain the anomaly.

A reproducible investigation of an apparent historical gas-price anomaly using archive-RPC block headers, retained CSVs and plotting scripts.

  • Python
  • JSON-RPC
  • CSV
  • Matplotlib
Engineering details

My contribution

Reconstructed the chart from a recorded 7,155-header sample and reconciled timezones, base fees and effective transaction prices.

The engineering decision

A chart can tell the wrong story when timezones and fee definitions differ. Reproducing the underlying series makes those differences testable.

Completed historical investigation · retained reproducible artifacts

Source locations

  • scripts/gas-cost-investigation/README.md
  • scripts/gas-cost-investigation/findings.md

Screenshots are preserved locally. Captures are historical; development previews are labeled. Upstream clients and platforms are credited as integrations.

THINKING ACROSS THE STACK

The interface is
only the beginning.

Provision. Collect. Reconcile. Serve.
A map of implemented components across my projects, each with its own lifecycle.

FOUNDATION

Infrastructure

Linux & bare metal
Execution clients
Consensus clients

Persistent storage, isolated networks, node lifecycle and health.

INGESTION

Data pipelines

RPC & beacon APIs
Collectors & indexers
Finality & reorg handling

Durable progress, bounded retries and data reconciliation.

SERVICES

Application backend

PostgreSQL / SQLite
Caches & API services
GraphQL integration

Storage selected per project, documented APIs and semantic health.

EXPERIENCE

Useful products

Analytics dashboards
Developer tools
Desktop & CLI

Network insight, supply analysis and understandable operator workflows.

DELIVERYTerraform · Ansible · Docker · GitLab CI

OPERATIONSPrometheus · Grafana · Loki · health checks · recovery

Readiness beyond reachability.

A responding node can still be stalled. A running indexer can still be behind. Health should describe useful work.

Recovery is part of the design.

Durable cursors, update journals and explicit maintenance ownership make interruptions something a system can handle.

Own the whole path.

Build tooling, data correctness and user interfaces belong in the same engineering conversation.

A CLOSER LOOK

Small details.
Real consequences.

Selected source excerpts from the work above.
The decisions behind the code matter as much as the syntax.

Prevent overlapping collectors

JavaScript
export async function runSingleFlight(state, key, fn) {
  if (state.get(key)) return false;
  state.set(key, true);
  try {
    await fn();
  } finally {
    state.set(key, false);
  }
  return true;
}
    
valdash/server/lib/single-flight.js

Only one collector runs for a key at a time. The finally block releases the guard after success or failure so one rejected request cannot wedge future work.

Require explicit update recovery

Rust
pub(crate) fn require_absent(options: &SupervisorOptions) -> Result<(), CoreError> {
    if load(options)?.is_some() {
        return Err(invalid(
            "an interrupted update requires explicit recovery before another operation",
        ));
    }
    Ok(())
}
    
PulseNodeManager/crates/pns-core/src/update_transaction_recovery.rs

An interrupted update is durable state. Reject conflicting operations until the operator explicitly recovers it.

Index within finality

Python
finalized_slot = get_finalized_slot()
if finalized_slot is None:
    logger.warning("Cannot get finalized slot from beacon API - will retry")
    return False

end_slot = min(target_slot, finalized_slot)
    
pls-api-com/app/slot_mapper.py

When finality is unavailable, retry later. Never map beyond the known finalized boundary. Selected excerpt; intervening comments omitted.

Detect stalled chain progress

Python
def is_stalled(state: WatchdogState, now: float, window_s: int) -> bool:
    return (
        now - state["eth_advance_at"] >= window_s
        and now - state["boundary_advance_at"] >= window_s
    )
    
tf-pulsechain/ansible/playbooks/common/nodes/rpc/stall_watchdog.py

Both progress clocks must expire before the watchdog declares a stall. A single delayed signal does not immediately drain a node. Reformatted source excerpt.

A NOTE TO THE COMMUNITY

Infrastructure shutdown scheduled.
The work carries forward.

Due to events outside my control, all G4MM4-operated PulseChain infrastructure is scheduled to shut down on November 21, 2026. The hosted websites, public RPC endpoints and supporting data services will go offline at shutdown.

Thank you to everyone who used these tools, shared feedback or helped others build. This portfolio preserves examples of the engineering behind them.

Read the full service update

LET’S BUILD WHAT’S NEXT

Need someone who can
connect the whole system?

I’m interested in infrastructure, backend, data-platform, full-stack and developer-tooling work. Consulting, contract, part-time and full-time opportunities are welcome.

Contact G4MM4 on X View engineering résumé

Tell me what you’re building, the role or scope,
and the best way to continue the conversation.