Dmitry Dube

prism

Ranks a codebase by graph centrality so a small local model reads the parts that matter rather than the parts that fit.

Built an AST and PageRank based context manager for local LLMs: Tree-sitter parses the source into a symbol graph, task-biased PageRank ranks it, and a compact index goes to the model, which then chooses what to read in full. On top of that sits a coding agent that plans a task into context-sized sections, executes them through a sandboxed tool loop, and tests after every edit. Then I built the benchmark, and it lost to a forty-line agent loop with none of the machinery.

Auction price prediction

Values an auction lot before anyone looks at it, and says how much to trust the number.

Built and deployed the price model behind an auction platform's intake: categorical embeddings and engineered numeric features through a Keras network, served from SageMaker. Rebuilt it to predict its own uncertainty, with two output heads trained on Gaussian negative log likelihood rather than MSE, so every valuation now carries a calibrated range instead of a bare number. Shipped it without breaking a single existing caller.

The model and the sale history it trains on belong to my employer, so the source stays private. What is described here is the architecture and the decisions behind it.

multiresolution-transformer

Forecasts market movement by fusing several timeframes inside one attention stack.

Built the data pipeline first: over 200GB of raw financial data, with a custom generator that transforms and caches on demand rather than materialising a working set that would have run past 10TB. The model reads several resolutions of the same series at once instead of committing to a single timeframe up front, and the work around it is the part that decides whether the result means anything: ablation studies, tracked hyperparameter runs and model versions, and time-aware splits designed so nothing leaks backwards across the boundary.

Auction intake agent

Turns a receiving clerk's data entry into a written, priced, and bundled auction lot.

Built an LLM pipeline that picked up where item intake began: a clerk recorded what arrived, then the chain generated the title and description, proposed a price, handed the item to a trained pricing model for the real valuation, and grouped it with similar items into a saleable lot. Orchestrated with LangChain over a tool server, working alongside one other engineer. The client stopped using it, first temporarily and then for good.

Built for an employer and since retired, so there is nothing to open. This is written from memory rather than from source, and it is deliberately thinner on implementation detail than the rest of these.

KYC document verification

Checks that the face on an ID belongs to the person submitting it, and that their proof of residence says where they claim to live.

Built the ML pipeline behind an automated KYC check: face verification between the ID portrait and a submitted selfie, and address verification that OCRs a proof-of-residence document and matches it against the address on file. The address matcher is the part that needed thought, since OCR returns one unstructured blob of text and the thing you are looking for is a short string somewhere inside it.

Built for an employer, so the source is not mine to publish. I wrote the ML pipeline; a colleague later moved it into a Flask and Redis service, which is why the repository history sits with him. The product it was built for never went live.

Tobacco barn detection from satellite imagery

Turns a GPS survey of known barns into a labelled training set, so a detector can find the ones nobody has surveyed.

Built a pipeline that generates its own object-detection training data: parse a KML survey of known tobacco barns, capture satellite imagery around each one, then project every surveyed coordinate into pixel space to write YOLO labels without anyone drawing a box. Trained a YOLOv5 detector on it and evaluated against independent grid tiles rather than barn-centred captures. The labelling approach worked; the detector did not reach usable accuracy.

Built for an employer against a client's survey data, so neither the imagery pipeline nor the coordinates are publishable.

raw-neural-net

A deep learning framework built from the array operations up, so that nothing in the training loop is a black box.

Worked through building a neural network library from scratch on NumPy, with no deep learning framework: dense and dropout layers, four activations, four optimizers including Adam, four loss functions with regularisation, and a model class that wires the layers together and runs the training loop. Trained it on Fashion-MNIST, then photographed my own clothes to see whether it held up on images that did not come from the dataset.

meme-sniper

Records every token launch on pump.fun so the current regime can be measured before anyone tries to model it.

Built a launch recorder and research platform for pump.fun after a protocol change invalidated every published threshold in the space. It runs a four-tier funnel shaped by free-tier API quotas, verifies the bonding-curve maths against live frames rather than documentation, and pins those constants in tests so a protocol change fails the suite instead of silently corrupting features. Currently recording; the kill criterion was written down before collection started.

RAR

A vehicle rental marketplace where renters, hosts, and admins all work against one API.

Lead developer on the whole product: a NestJS and Postgres backend of 24 modules serving one REST surface, a React web client of 50 pages covering customer, vendor and admin, and a Flutter app of 36 screens on iOS and Android. Built four rental products on that base, payments across Stripe, PayPal and PKPay mobile money with webhook-driven booking creation, KYC with facial liveness and document matching, in-app messaging, and the bid and counter-offer flow.

The web product is live and you can go use it. The repositories belong to the company and stay private, so this is architecture and decisions rather than code. The mobile app is built and running against the same API; store availability is not a claim I will make here until it is confirmed.

Firefun

Finds the events and the venues open near you in Harare, and gives organisers somewhere to publish them.

Built an events and places discovery product for Harare across three surfaces on one Firebase backend: a Next.js 15 web app, a React Native and Expo mobile app, and Cloud Functions, with the rules both clients must agree on living in a shared package. Wrote the browse layer against geohash-bounded proximity queries after the unbounded version started pulling megabytes to render twelve cards, and built an event import pipeline that reads feeds, structured metadata and OCR'd posters, then extracts structured events through a local model with provenance back to the evidence.

The source is not public. The site is up and under test, so the product itself is the demo rather than a writeup standing in for one.

GPS fleet tracking

Tracks a vehicle fleet in real time, with geofence breaches pushed to an admin phone as they happen.

Worked on a fleet tracking system built on Traccar, with a Django and React server on EC2: configured the tracker units themselves, set up the geofencing rules, and wired live alerts through to a React Native admin app as push notifications. Junior developer on a small team, alongside another developer who added phone-as-tracker support next to the dedicated hardware.

Built in-house for a former employer and no longer accessible to me, so there is nothing to open and no writeup behind this one.

Offline-first point of sale

Keeps a restaurant taking orders through a network outage, then reconciles to the ERP without losing a transaction.

Lead developer on a three-tier POS: ERPNext as the central system of record, a Django and SQLite server at each site that keeps taking orders when the internet is gone, and an Electron and React terminal at the counter with fingerprint authentication through a C++ Node addon. Built the sync engine that queues every local write with its dependencies and drains it across four concurrent loops, and spent most of the hard time on SQLite lock contention on the low-powered hardware these sites actually run.

Built for an employer and running in client sites, so the source is not mine to publish. This describes architecture and the problems that actually cost time.

RAR staging and deploy pipeline

A staging environment that mirrors production without being able to touch real money.

Brought production-only code back under version control, then built staging from scratch on a clean Ubuntu VPS: deploy user, firewall, Nginx, TLS, Postgres, and PM2, with every third-party provider in sandbox mode. GitHub Actions deploys develop to staging and main to production over SSH, staging verifies the process is both online and serving before the deploy is allowed to pass, and schema changes go through idempotent SQL against a database where auto-sync is deliberately off. Wrote the sixteen-step runbook so the box can be rebuilt by someone who is not me.

Infrastructure for a live company, so there is nothing to open, and some specifics are left out on purpose.