// INFRA_DEVOPS
RESTRICTED ACCESS
This portfolio is shared on request only.
To request access, contact:
Email [email protected]
LinkedIn — coming soon
Infrastructure & DevOps Portfolio

Infrastructure Engineer

// Node Ops · DevOps · Observability · Automation

Four production-grade projects demonstrating node infrastructure, full observability, CI/CD automation, and forensic intelligence — built to production standard and used in real world operations.

DEMO-READY // All projects can be run live on a Linux CLI environment
4
Production Projects
18+
Technologies
2
Deployments: ETH · BTC
// PHOTO

Apu Saha

Self-taught infrastructure engineer building node infrastructure, observability pipelines, and forensic analysis tools.

I didn't come from tech. I built my way into it. And I'm not finished.
Background Self-Taught
Location Melbourne, AU
LinkedIn — coming soon
Mobile +61 451 195 990

I came from restaurant kitchens. Seven years of nights, weekends, and double shifts — the kind of work where you learn endurance before you learn anything else. When COVID hit, I lost my job overnight.

I took whatever work I could find. I moved into food manufacturing — production lines, heat, heavy lifting, long shifts managing teams. Over time my back, knees, and wrists started breaking down. I was spending money I didn't have on physio just to stay functional enough to show up the next day. I had a daughter to raise. No safety net. No fallback.

I drove Uber on weekends until a dangerous incident forced me to stop. I spent two years studying Forex — building scripts, backtesting strategies, learning risk management. The markets taught me pattern recognition and discipline. The losses taught me something more valuable: humility, and the real cost of shortcuts.

Then I invested in a blockchain project that turned out to be a scam. It hurt financially. But it introduced me to something that changed everything — infrastructure.

A community member helped me run my first Linux node. I had never touched Linux before. I didn't know Docker, networking, automation, or system administration. But something clicked.

I rebuilt nodes from scratch. I debugged failures at midnight after factory shifts. I learned Docker, container isolation, monitoring pipelines, backup strategies, and recovery workflows. I went from asking questions to answering them. Within the community I became the person people came to when their nodes broke. Even after the project collapsed and the scam was exposed — I didn't stop.

Working in kitchens taught me to perform under pressure without losing precision. Factory floors taught me resilience and consistency. Forex taught me to read patterns and manage risk. Fatherhood taught me to think in decades, not weeks. Loss taught me to question every assumption. Those lessons show up in every system I build.

My path wasn't linear. It wasn't clean. There were years where survival took priority over ambition. But every setback sharpened something. Every late night debugging alone built something that a classroom never could. Every system I had to fix under pressure — with no mentor, no team, no safety net — that's the engineer I became.

// P-01 Pre-Forge Operator Toolkit — from real broken nodes, failed syncs, and a community that needed tools that actually worked.
// P-02 MultiSig Treasury — from watching a community lose millions because trust existed without verification.
// P-03 OmniNode — from the nights spent fixing broken nodes after factory shifts, needing infrastructure that ran itself.
// P-04 TX Monitor — from the frustration of not knowing what was happening inside a live system until something had already failed.
// P-05 Neural Tracer — from a personal loss that became a federal investigation. Some details remain confidential.

My engineering mindset was shaped by kitchens, factory floors, financial loss, and rebuilding myself through infrastructure.

Everything I build now comes from the same place: resilience, clarity, and real-world pressure.

01

Projects

01
BASH · LINUX · DOCKER

Pre-Forge Operator Toolkit

A collection of 23 bash tools built while running real BlockDAG node infrastructure for a community of operators. No formal architecture. No structured design process. Just real problems showing up — broken nodes, corrupted databases, failed syncs, permission errors — and scripts written to fix them.

Every tool here was deployed back to real community members. Some were rewritten multiple times when they failed in the field. Some were deleted entirely when they weren't good enough. What remains is what actually worked.

All of this was built before we found out the project was a scam. The community was real. The problems were real. The work was real.

  • 6 node installers — from single-file scripts to a self-healing installer that rewrites its own source code when the download link breaks
  • Linux performance optimizer with full reversal capability — every change is backed up before it's made
  • Sync ETA calculator, peer latency analyser, and port diagnostics for live nodes
  • RocksDB corruption scanner — isolates faulty .sst files away from the node root
  • Backup, restore, and a shared-drive sync tool so falling-behind operators could jumpstart to today's state
  • Browser-based presale transaction tracker across 15 chains — became the seed for WalletDNA
Pre-Forge terminal output
// Tools Used
Scripting
Bash
Environment
Ubuntu Linux
Containers
Docker + Compose
Database
RocksDB
Node Comms
JSON-RPC
Alerts
Discord Webhooks
Web
HTML · JavaScript · SheetJS
// What This Proves
No formal education. No university. No bootcamp. Learning by building — with AI as the only teacher and real broken infrastructure as the classroom. Direct feedback loop — broken node reported, script written, redeployed to community. This is the foundation everything else was built on.
02
Smart Contracts · Security

MultiSig Treasury Wallet

A production-grade multi-signature treasury wallet built from scratch on Ethereum Sepolia. The same architecture used by Gnosis Safe to secure billions in DAO treasuries worldwide — built from first principles to understand every security decision, every state transition, and every governance pattern under the hood. No shortcuts. No wrappers.

  • 2-of-3 multisig threshold — no single owner can move funds, every transaction requires consensus
  • Three-stage flow: Submit → Confirm → Execute, with one-way execution door preventing replay attacks
  • Dynamic owner management — add, remove, and change thresholds via on-chain governance
  • Deployed to Sepolia with live Etherscan contract verification and publicly auditable source code
  • Real bug found and fixed in production — pause lockout that would have permanently locked funds on mainnet
  • 25-test suite covering deployment, deposits, governance, and edge cases — CI/CD enforced on every push
MultiSig terminal output
// System Layers
Contract
Solidity 0.8.28 · Checks-Effects-Interactions
Network
Ethereum Sepolia · Alchemy RPC
Interface
React · MetaMask · Ethers.js v6
Monitoring
Node.js · WebSocket event listener
Metrics & Alerts
Prometheus · Discord Webhooks
CI/CD
GitHub Actions · 25-test gate · Etherscan verification
// What This Proves
Security-first smart contract development from first principles. Not configuring a tool — understanding what the tool is doing. Production deployment and Etherscan verification workflow. Testing discipline with full edge-case coverage. A real critical bug found, diagnosed, and fixed before it could cause permanent damage.
03
Node Ops · Kubernetes · IaC

OmniNode Infrastructure Manager

A multi-chain blockchain node infrastructure platform running Bitcoin Core and Ethereum simultaneously in a containerised, orchestrated environment. Nine Docker containers. Full observability stack. Automated operations from a single CLI. This is what production infrastructure teams run every day — built from scratch to understand every layer.

  • Bitcoin Core + Geth running concurrently in Docker with automatic resource limits based on host hardware
  • Single CLI to start, stop, restart, and health-check all 9 containers across both chains
  • Full Grafana observability — custom dashboards with blockchain-specific metrics via Prometheus
  • Terraform provisions cloud infrastructure in one command — DigitalOcean droplet, firewall, 100GB storage volume
  • Ansible playbook automates full server provisioning — 22 tasks, zero manual steps
  • Kubernetes manifests included — tested on minikube, orchestration capability demonstrated
OmniNode terminal output
// Tech Stack
Data Source
Bitcoin testnet · Ethereum Sepolia · Lighthouse beacon
Ingestion
Bitcoin RPC · Geth RPC · Lighthouse HTTP API
Processing
Python exporter · Health checks · Normalisation
Core Logic
Multi-node orchestration · Node monitoring engine
Storage / State
Prometheus TSDB · Node state files
Output / Delivery
Grafana dashboards · Alertmanager · Discord Webhooks · GitHub Actions
// What This Proves
Production node operations across two chains simultaneously. Docker proficiency from first principles — 9 containers, custom exporters, health watchdogs. Ansible for infrastructure provisioning and configuration management — IaC patterns understood and demonstrated. Complete Prometheus and Grafana observability stack wired from scratch. Kubernetes exposure via minikube — manifests tested and documented.
04
Real-Time Data · ETH · Observability

Real-Time Blockchain(ETH) Txs Monitor

A live Ethereum mempool monitor that streams, filters, and analyses transactions before they're confirmed. Built to run 24/7 on a headless production server — no GUI, no manual intervention. Processes real mainnet data at production throughput with intelligent pattern detection built in from day one.

  • Live WebSocket stream from Ethereum mainnet — transactions seen before block confirmation
  • Filter chain classifies every transaction: whale, large, gas spike, private, contract type
  • Anomaly detection engine flags volume spikes and sustained gas abnormalities across rolling time windows
  • DFS recirculation detection — identifies circular fund flow across up to 5 hops within a 1-hour window
  • Rich terminal dashboard with live stats — headless-ready for production Linux servers
TX Monitor terminal output
// Tech Stack
Data Source
Ethereum Mainnet · CoinMarketCap price feed
Ingestion
Alchemy WebSocket · Python asyncio
Processing
Filter chain · Anomaly detection
Core Logic
Custom Python pipeline · Rolling window analysis
Storage / State
SQLite
Output / Delivery
Python Rich dashboard · Prometheus · Grafana · GitHub Actions
// What This Proves
Real-time async data pipeline at production throughput. Pattern detection applied to live blockchain data — not toy datasets. SQLite storage for transaction history. Kubernetes deployment and CI/CD enforced on every commit.
05
FORENSIC INTELLIGENCE · ETH · ACTIVE CASE

Neural Trace

A blockchain forensic investigation tool that traces wallet activity forward and backward across the Ethereum network. Built from personal loss — used in an active federal investigation. Generates court-ready reports for legal authorities.

  • Forward tracer maps fund flow up to 7 hops from a single wallet address — no prior knowledge needed
  • Origin tracer works backwards up to 7 hops — identifies where funds came from
  • Monitor engine tracks 48hr or 7-day real-time activity across all traced wallets
  • Intelligence layer auto-classifies wallets — operator, aggregator, mixer, bridge, exchange
  • Generates structured JSON and DOCX reports — AI assisted narrative layer produces final documents submitted to federal attorneys
  • HTTP Basic Auth + API key isolation — credentials never exposed to browser
  • 38 automated tests across analysis, exchange detection, and intelligence modules
Neural Trace terminal output
// Tech Stack
Data Source
Etherscan API v2 · CoinGecko price feed
Ingestion
Python 3.11 · Node.js server · SSE streaming
Processing
7-hop graph traversal · Pattern recognition · Dormancy detection
Core Logic
Behavioural wallet classification · 76 known exchange registry · Structuring detection
Storage / State
JSON file system · DOCX report generation
Output / Delivery
Browser dashboard · Word documents · Attorney-ready reports
// What This Proves
Built for and used in a real federal investigation — not a demo project. Forensic analysis applied to live Ethereum mainnet data. Reports submitted to attorneys and accepted as investigative evidence. Some case details remain confidential.
02

Skills Matrix

// Infrastructure
  • Docker + Docker Compose
  • Linux Administration (Ubuntu)
  • Bitcoin Core Node Ops
  • Geth (Ethereum) Node Ops
  • Kubernetes (Minikube — local)
  • Terraform (IaC — local development)
  • Ansible (Config Management)
  • Bash scripting (automation)
  • systemd + cron + SSH
// Observability
  • Prometheus (metrics collection)
  • Grafana (custom dashboards)
  • Alertmanager (alert routing)
  • Discord webhooks
  • Container log export (timestamped, auto on shutdown)
  • Structured logging
  • Health watchdog (independent monitoring)
  • Performance benchmarking
// Development
  • Python (data pipelines, analysis)
  • JavaScript / Node.js
  • GitHub Actions (CI/CD)
  • Automated testing (unit + integration)
  • REST API integration
  • WebSocket streaming (asyncio)
  • Environment config management
  • Report generation (JSON + DOCX)
// Security & Analysis
  • Credential management (.env, secrets)
  • Access control implementation
  • API key isolation
  • Anomaly detection
  • Behavioural pattern recognition
  • Evidence handling
  • Recirculation detection
  • Restricted access control
03

Architecture Philosophy

// 01
Terminal-First Design
All tooling runs headless. Production servers don't have GUIs. Every interface in this portfolio reflects that reality — built to run 24/7 on a remote Linux box without a human watching.
// 02
Observability Built In
Prometheus metrics, Grafana dashboards, and structured logging are not afterthoughts — they are first-class requirements that go in at day one, not bolted on at the end.
// 03
Security as Architecture
Access controls, multisig patterns, and security decisions are designed into the system from the start. Security decisions appear in architecture diagrams, not just in code comments.
// 04
Automation Over Manual Ops
Bash scripts, Ansible playbooks replace every manual step. If a human has to do it twice, it gets automated. Repeatability is non-negotiable.
// 05
CI/CD From Day One
Every project has GitHub Actions pipelines initialised before the first feature commit. No code reaches testnet or production without passing automated tests. This is the baseline, not the goal.
// 06
Documentation as Code
Architecture diagrams, README files, and deployment guides are produced alongside the code — not after. A system nobody else can operate is an incomplete system.