# John Kingola: Quant engineering resume

> Quant engineer · Strategy parameters, entry filters, and backtesting infrastructure · Rust and Python. Nairobi, Kenya (UTC+3) · remote as a contractor or through an EOR · no visa sponsorship needed.

I check that something is true before anyone relies on it: trading strategies, AI agents, and the systems around them.

- **6 yrs** trading systems, since 2020
- **241** LEAN indicator types ported to Rust
- **5** upstream fixes merged and credited
- **129** testing methods in Cernos

I design the parameters and filters that decide when a trading system acts, and build the infrastructure that shows whether the result is real. In Cernos I ported LEAN's indicator library to Rust (241 indicator types) inside a research engine that translates strategies from eight languages into one portable format, counts every parameter trial against overfitting, and exports the winner as standalone Python or C++. I rebuilt published FX and gold systems from their trade logs, tuning filters on one half of the data and judging them on the other. I have done this for six years, since 2020, from MQL5 Expert Advisors built to client risk specifications to a backtest-as-a-service API with a cache keyed on the strategy hash. Currently technical advisor on algorithmic systems for a trading startup, and lead engineer behind the Change Intelligence Platform, which I built end to end and now maintain.

### Why hire me: decisions, and how I checked them
- **How do you set an exit when the training data holds two trades?** Thought: Two engine cycles per variant is too few to fit anything. A fitted exit would only be a search that looks like a result. Tested: Derived it from costs instead: take-profit at 450 ticks, which is 346 of round-trip maker fees plus 55 of measured one-second drift plus a margin, and an exit at the touch after 60 seconds. Result: No free parameter was left to overfit, so the test that followed judged the idea, not the tuning. Proof: [Liquidity Engine study](https://github.com/Astralchemist/liquidity-recycling-engine/blob/main/docs/study/README.md).
- **Was the gate's edge real, or one lucky session?** Thought: Session D's advantage (t ≈ 2.3 on six cycles) came from the only session I had already looked at. Tested: Committed three hypotheses, the variants, the commands and the exits before replaying session E, against an ungated control with identical exits. Result: All three hypotheses failed. I reported it as registered, and the README leads with the negative result. Proof: [Evidence page](https://astralchemist.github.io/liquidity-recycling-engine/evidence/).
- **Is a copied trading rule the vendor's rule, and does it survive costs?** Thought: A rule can match a vendor's trades and still be noise once spread and commission are paid. Tested: Inferred a fade rule that matches 88% of one vendor's 2026 trades, tuned filters on January to June and judged them on July to October, then audited costs on live demo fills: $7.33 per lot round trip against the $7 assumed. Result: Only 33% of profitable setups held up, and one-shot holdouts failed after costs. Nothing went further than a demo forward test. Proof: Private research repo, described.
- **Are the numbers in the quant libraries everyone uses correct?** Thought: Performance statistics are easy to get subtly wrong and rarely checked against reference values. Tested: Ran reference-value tests and benchmarks against ffn, skfolio, quantstats, Databento dbn, gs-quant, Qlib and barter-rs, and retested every bug on a fresh clone before filing. Result: Five fixes merged and credited (ffn v1.3.0, skfolio v1.4.1); quantstats and Databento fixed what I reported. Proof: [github.com/Astralchemist](https://github.com/Astralchemist).

### Projects
- **Cernos** (Strategy research engine in Rust, LEAN indicators ported; Pre-release · private repo). A terminal tool that finds trading strategies on the web, translates them into one JSON format with an LLM, checks each translation against the original code in a sandbox, backtests and breeds them, and exports the winner as standalone Python or C++. Hard part: Counting every parameter trial. The first gauntlet records each parameter set it tries and judges with CSCV/PBO and a probabilistic Sharpe of at least 0.95, so tuning cannot hide in the result. The first BTC-USD run failed all 12 trials. Stack: Rust, OpenRouter LLM loop, Sandboxed containers, Python and C++ export.
- **Strategy Rebuilds** (16 published FX and gold systems, reverse-engineered; In progress · private). Rebuilt published MyFxBook systems from their trade logs: profiled 16, inferred their entry rules, and ported the strongest to MT5 and to a core-plus-adapters Python kit where session, trend and pause filters attach without touching the entry logic, then tested them on real broker ticks. Hard part: Separating an edge from tuning. Filters were chosen on January to June 2026 and checked on July to October; only 33% of profitable setups held, and one-shot holdouts with hashed configs failed after costs. Live demo fills then confirmed the cost model. Stack: MQL5, MT5 real-tick tester, Python, Dukascopy and broker ticks.
- **Liquidity Engine** (BTC order-book research, pre-registered; Public · negative result). A deterministic Rust engine that records BTC perpetual order books on three venues, replays them exactly, and tested a market-making strategy that does not work at retail fees. Hard part: Measuring what a fill costs. Probes resting at the touch saw 41 to 66 ticks of adverse drift within one second on every venue, in every session, under every fill model. Stack: Rust, WebSocket feeds, L2 queue model, Python figures.
- **Backtest API** (Trading infrastructure; Private, described architecturally). Backtest as a service: the boring parts, built so the same strategy is never computed twice. Hard part: Cache keys that survive strategy edits. The same strategy is asked for a hundred ways, so the key is the strategy hash, not the request. Stack: Python, FastAPI, TimescaleDB, Redis, Docker.
- **Signly** (Forex signal verification; Maintained, not live). Verify Telegram trading signal channels before trusting them. Built and shipped, and maintained; not live, with the public site offline. Hard part: Parsing free-text signals reliably, and defining a verdict that penalises stop-loss indiscipline instead of rewarding win rate. Stack: Python, FastAPI, Polygon, PostgreSQL.
- **Trading Strategy Library** (Public quant work; Open source). A strategy catalogue plus research tools, from indicator to execution to statistics. Hard part: Keeping research honest. The research suite is labelled research-only in its own README, and that label stays. Stack: Python, MQL5, NumPy, QuantConnect Lean.
- **Rig** (Semantic codebase graph over MCP; npm v0.3.0 · Show HN). npx rig-constellation gives a coding agent a map of the codebase instead of grep. Local-first, no key, nothing uploaded. Hard part: About 100 commits in four days to v0.1.5, stable per-project ports, and keeping the map live during indexing. Stack: TypeScript, MCP, Node, SQLite.
- **CreditWatch** (Cloud-credit runway from the menu bar; 1.0.0 released 2026-09-21). Answers one question: how long does the prepaid GPU credit last at the current burn. Hard part: The account schema documented balance. A live account proved the spendable figure is credit. Windows and Linux were built and unit tested but not claimed, because no human had run the installed binary. Stack: Kotlin, Compose Desktop, SQLite, Keychain.
- **StickyInc** (Commitment pane fed by MCP; v0.5.1 · v0.6 in review). Tell an LLM to call the dentist Friday, an MCP tool call fires, and a checkbox appears on screen. No backend, ever. Hard part: Detecting whichever agent CLI is installed without asking for a key or a config file. Stack: TypeScript, Rust, Tauri, MCP.

## Experience
- **The Change Intelligence Platform**, Lead engineer (contract), then maintainer (Dec 2025 to Present, Dubai, UAE · remote)
  - Built and shipped the platform solo in six months, Dec 2025 to Jun 2026, from architecture to production, under the direction of change-management practitioners. On retainer since for maintenance and feature work.
  - Multi-tenant change-management SaaS: Next.js and FastAPI on a Docker Compose stack with Supabase. Fine-tuned Llama 3.1 8B and served it with vLLM on a Modal L4 GPU, behind an OpenAI-compatible API with an OpenRouter fallback.
  - Four role-based tiers, including a delegated Champion portal with magic-link auth, PDF export via Puppeteer, a seven-tag sentiment model, and an automated LinkedIn outreach pipeline.
  - Led a latency and build-performance pass after an audit surfaced I/O-wait bottlenecks and N+1 query patterns.
  - Stack: Next.js, FastAPI, Python, Supabase, PostgreSQL, Docker Compose, Llama 3.1 8B, vLLM, Modal, OpenRouter, Puppeteer
- **Early-stage stealth startup**, Technical advisor, algorithmic systems (Oct 2025 to Present, Dubai, UAE · remote)
  - Joined as lead algorithmic engineer at the founding stage, then moved to an advisory role while funding closes.
  - Designed the backtest-as-a-service API: FastAPI, TimescaleDB, a Redis cache keyed on the strategy hash, and per-key rate limits.
  - Stack: Python, FastAPI, TimescaleDB, Redis
- **ConsultHasha**, Principal systems engineer (2024 to 2025, Nairobi · hybrid)
  - Early engineer at a startup. Designed and built the REST API layer and the production service endpoints the product and its client integrations ran on.
  - Owned architecture, deployment, and reliability.
- **Upwork**, Freelance quant and full-stack developer (2020 to 2025, Remote)
  - MQL5 and MT5 Expert Advisors built to client risk specifications, then Python backtesting tools, Telegram signal bots, and execution dashboards.
  - Also Docker-first Next.js and Postgres client platforms.
  - Stack: MQL5, MetaTrader 5, Python, Telegram bots, Next.js, PostgreSQL, Docker

## Skills
- Trading and research: Backtesting engines, Signal extraction, L2 order books, markouts, and adverse selection, Power laws and EVT, MQL5, MT5, and Pine Script, QuantConnect Lean
- Data and backend: Python, FastAPI, PostgreSQL and pgvector, TimescaleDB, Redis, RabbitMQ
- Web and product: TypeScript, React, Next.js, Tailwind CSS, Node.js, Supabase
- Tooling and desktop: Rust (Tauri, research engines), Kotlin (Compose Desktop), MCP servers, npm publishing, SQLite, Linux and VPS ops
- Delivery: Docker Compose, GitHub Actions CI, Cross-platform credential stores, Release engineering, Latency and build-performance passes, Upstream PRs to quant libraries
- AI and GPU inference: vLLM on CUDA GPUs (Modal L4), PyTorch, Hugging Face Transformers, Accelerate, KV-cache and GPU memory tuning, Llama 3.1 8B fine-tuning and serving, Claude, OpenRouter, Ollama fallback, Tool-calling loops, embeddings, and RAG

## AI tools I build with
- **Claude Code** (Anthropic): Daily coding agent. Rig wires its MCP server into it, and StickyInc runs on it through claude -p with no API key.
- **Cursor** (Anysphere): AI editor. Rig wires its MCP server into Cursor, so the editor's agent queries the codebase graph instead of grepping.
- **Codex** (OpenAI): CLI agent. Rig wires into it, and StickyInc can run on it through codex exec.

Web version: https://kingola.dev/resume/quant/ · PDF: https://kingola.dev/john-kingola-resume-quant.pdf · Contact: kingolajohn55@gmail.com