Services

What we take on, how it is delivered, and the engagement process we follow.

An engagement begins when you send us your requirements — typically a paper, draft, repository, or written brief. We assess the request, and if it falls within our scope, we follow up promptly with a proposed scope, timeline, and price.

Once the work is underway, we collaborate with you through regular written progress updates, and we deliver the agreed artifacts at the scheduled milestones.

Our engagements do not include general web development, long-term staff augmentation, or work whose objective is to support a sales motion.

1

Public Paper Reproduction

Implement algorithms from published papers when the official code is missing, incomplete, or fails to reproduce reported results. We follow the paper's description carefully, fill in undocumented gaps with defensible engineering choices, document every assumption we make, and verify the implementation against the paper's reported metrics.

Typical request "There's a paper from last year whose method matches our research direction, but the public repo only has inference code — no training pipeline, and the data preprocessing is described in a single sentence in the appendix. Before we can build on it, we need a runnable end-to-end implementation whose numbers actually match the paper."
Per-engagement deliverables
  • Source code implementing the paper's method, end to end
  • Experiment scripts that reproduce the paper's main reported metrics
  • A reproduction report: metric comparison table (ours vs. paper), engineering choices, deviations, and known gaps
  • README with the paper citation, environment setup, and one-command reproduction instructions
2

Implementation of Client Research

Implement the algorithm or method described in the client's own paper, draft, technical note, or design document. We work iteratively from the client's specification and through a continuous question-and-answer loop with the researcher who designed the method — the objective is code that exactly reflects the client's method, not our interpretation of it.

Typical request "Our research group does not have the engineering depth in-house — our own implementation of the method produces results that fall well short of the theoretical numbers we expect. We need outside technical experts to close the engineering gap so the implementation behaves as the theory predicts."
Per-engagement deliverables
  • Source code implementing the client's method as specified, with a structure intended for future extension
  • A spec-to-code mapping document — which file/function implements which section or equation of the draft
  • Implementation notes: every question we asked the researcher and the answer we received
  • Test suite verifying the implementation against the client's reference cases
3

Algorithm Benchmarking & Prototype Validation

Validate algorithm performance against baselines, on standard or client-specific datasets. We design the experiment protocol, run controlled comparisons with fixed seeds, profile compute / memory / latency, run ablations, and deliver a reproducible report with metric tables, plots, and a candid analysis of the conditions under which the algorithm performs and the conditions under which it does not.

Typical request "We are a corporate engineering team. We have come across several new algorithms in recent papers that look applicable to our data, but we do not have a research background in-house. We want outside experts to evaluate how these algorithms actually perform on our internal data and to produce a comprehensive report covering their strengths and weaknesses across the relevant dimensions — so that our engineering departments have a sound basis for technology selection going forward."
Per-engagement deliverables
  • Experiment protocol document: datasets, splits, seeds, hyperparameters, hardware
  • Benchmark report: metric tables, ablation tables, latency/memory profiling, error analysis
  • Raw experiment logs and the analysis scripts that produced every table and plot
  • Reproducible run scripts (single command per reported number)
4

Research Code Productionization & Reproducibility

Take code that runs only on the original author's machine and transform it into a clean, documented, containerized repository — readable code, unit tests covering critical components, a substantive README, pinned dependencies, a Dockerfile, deterministic experiment scripts, and a reproducibility note for reviewers or future collaborators.

Typical request "We want to open-source the code from a recent paper, but right now it is a single 1,200-line file with hardcoded paths, half-finished branches, three different ways of loading the dataset, and no instructions. We need it cleaned up to a state we can actually attach to the paper without embarrassment."
Per-engagement deliverables
  • Cleaned, modularised source code with a clear file layout
  • Unit tests covering core invariants (not coverage for its own sake)
  • Dockerfile, pinned dependencies, and a brief native-install path
  • README covering quickstart, dataset preparation, and result reproduction
  • Migration notes mapping the old layout to the new one
5

Algorithm Demos & Small Startup MVPs

Package a working algorithm into a demonstrable artifact — an interactive web demo for a paper, conference, or pitch, or a small algorithm-core MVP for an incubating startup that needs to ship a first runnable version to its first users or investors quickly. We do not build full products; we build the minimum that enables an actual user to interact with the algorithm.

Typical request "We are a technology-driven startup currently incubating, still in our early operating phase. Ahead of our next funding round we need an MVP that demonstrates the feasibility of our core algorithm. Our early-stage funding and limited public profile make it hard to attract a full-time algorithm engineer in time, so we want to outsource part of the MVP. The underlying technology was previously shown as a demo at academic conferences — the implementation is genuinely non-trivial, and a general outsourcing firm cannot complete it. We need a partner with an academic background."
Per-engagement deliverables
  • Deployed demo (or deployment instructions for your infrastructure)
  • Front-end and back-end source code, with a clear seam between algorithm core and UI shell
  • Hosting / runtime notes (resource needs, scaling, secrets handling)
  • For MVPs: a short hand-off note so the algorithm core can be upgraded later by a different engineer

Pre-Handover Checklist

Every engagement is hand-checked against this list, regardless of which service it falls under. The phrasing below is calibrated to a Python / ML engagement; the equivalent hygiene items for other stacks are applied case-by-case.

Reproducibility

  • Deterministic execution — RNG sources seeded and asserted at run start (e.g. NumPy / PyTorch / CUDA / Python random for Python projects)
  • One-command reproduction — make reproduce (or equivalent) regenerates the main reported result
  • Script-generated outputs — final tables and plots produced by a script, not transcribed by hand

Environment hygiene

  • Reproducible environment — Docker / Conda / Singularity / equivalent builds and runs cleanly on a fresh machine of the agreed kind
  • Pinned dependencies — exact versions, lock file committed
  • No hard-coded paths — datasets, outputs, and credentials configured via env vars or config files
  • Tests pass cleanly — the test suite passes from a fresh environment build

Hand-over hygiene

  • Trace-aware logs — every log line includes the full command, hostname, and git commit
  • Credentials scrubbed — all credentials and absolute paths removed from git history
  • LICENSE in place — file present and consistent with dependency licenses
  • Known limitations documented — a "Known limitations" section in the README

Process

1
Read & Align

We read the client's paper, draft, or method specification carefully, then communicate directly with the client to confirm the exact interpretation, success criteria, and definition of completion.

2
Execute & Verify

We execute the work iteratively in small steps — whether that is implementing, benchmarking, refactoring, or building a demo — and validate at every milestone against the client's reference points: paper metrics, baseline outputs, theoretical numbers, or the client's own test cases.

3
Hand Over Reproducibly

We hand over not just code but a runnable repository: documentation, scripts, environment definition, and a reproducibility note so a future researcher or engineer can rerun every reported result.

To discuss a paper, draft, or prototype: ✉ bd@sciwealth.com