Workflow development
Modular, reproducible pipelines in Nextflow (with nf-core) or Snakemake—built to scale from a handful of samples to thousands.
Core Bioinformatics
Custom Pipelines & Software
From a fragile script to production-grade infrastructure. We build reproducible Nextflow and Snakemake pipelines and custom tools—containerised, tested, and deployable to your cloud or HPC—and hand back a documented, version-controlled repository your team can run and extend.
Your tools & data in
Pipelines · tools · deployment out
Typical turnaround 3–7 days
Individual pricing from $149
Illustrative sample workflow
process
parallel step
output
Overview
Reproducible pipelines & software, built to last
A good pipeline is more than a chain of commands—it runs the same way on a laptop, a cluster, and the cloud, survives the person who wrote it leaving, and produces the same result next year. The hard part is rarely the individual tools; it is structuring the workflow so it is modular, containerised, tested, and portable, and documenting it so your team can trust and maintain it.
We build and deliver that for you. Whether you need a new analysis pipeline, a custom tool or package, a data-processing system, or an existing workflow modernised, we use established frameworks—Nextflow, nf-core, Snakemake, containers, and CI—and hand back a version-controlled repository with tests, run configurations, and documentation so it reproduces exactly and keeps working.
Capabilities
What we analyse
One service spanning the software lifecycle—from workflow design and containers to deployment, data engineering, and CI.
Containerization & environments
Per-step Docker or Singularity/Apptainer containers and pinned Conda environments so results are identical anywhere.
Cloud & HPC deployment
The same pipeline runs on your laptop, a SLURM cluster, or the major clouds—we set up the configuration and infrastructure.
Custom tools & packages
Command-line tools, R and Python packages, and APIs—engineered, documented, and published where you need them.
Data engineering & databases
ETL, data models, and databases that keep large, messy datasets organised, queryable, and analysis-ready.
Scaling & optimization
Parallelisation, resource tuning, and cost control so pipelines run faster and cheaper without changing the science.
CI/CD & testing
Automated tests and continuous integration so changes are validated before they ship—no silent breakage.
Web apps & portals
Interactive apps and data portals that let collaborators submit jobs, browse results, and share data securely.
The Process
How we build a pipeline
A transparent, engineering-grade process—each stage agreed with you and documented, so you own something maintainable, not a black box.
Steps are adapted to your project: a new build vs. modernising an existing one, a single tool vs. a full platform, HPC vs. cloud. We agree scope and milestones with you before we start.
Scope & requirements
We map the analysis, inputs and outputs, scale, and where it needs to run—then agree the design and milestones.
Output: requirements · architecture · plan
Design & prototyping
A modular architecture is drafted and a prototype validates the approach on real data before full build-out.
Tools: Nextflow DSL2 · Snakemake · DAG design
Implementation
Each step is built as a self-contained, reusable module, wiring in existing tools and any custom code you need.
Tools: Python · R · nf-core modules
Containerization
Every step gets a pinned container or environment so the pipeline is portable and byte-for-byte reproducible.
Tools: Docker · Apptainer · Bioconda
Testing & CI
Automated tests and continuous integration catch regressions on every change—with small test datasets that run fast.
Tools: nf-test · pytest · GitHub Actions
Deployment
Run configurations are set up for your infrastructure—HPC scheduler or cloud—and validated end to end.
Tools: SLURM · AWS · config profiles
Docs & handover
A documented repository, usage guide, and walkthrough so your team can run, extend, and maintain it confidently.
Output: repo · docs · handover session
Tools & Technologies
Established, peer-reviewed tools—matched to your data
We select from the field's standard toolkit rather than forcing every dataset through one pipeline. A representative set of what we work with:
Workflow managers
Nextflow
nf-core
Snakemake
WDL
Cromwell
CWL
Containers & environments
Docker
Apptainer
Conda
Bioconda
mamba
Cloud & HPC
AWS
Google Cloud
Azure
SLURM
Kubernetes
Terraform
Languages
Python
R
Rust
Bash
Groovy / DSL2
C++
CI/CD & testing
GitHub Actions
GitLab CI
nf-test
pytest
testthat
Data & storage
PostgreSQL
DuckDB
Parquet
Polars
S3
Web & APIs
FastAPI
Flask
Shiny
Streamlit
Plumber
Version control & registries
Git
GitHub
PyPI
CRAN
Zenodo
Foundations
Standards & ecosystems we build on
Durable software rests on proven frameworks and community standards. We build within the ecosystems your team can trust and maintain.
- Nextflow & nf-core
- Dataflow workflow engine and its library of peer-reviewed pipelines.
- Snakemake
- Python-based, file-oriented workflow system for reproducible research.
- Docker & Apptainer
- Containerisation for portable, reproducible execution anywhere.
- Bioconda
- Community-maintained packaging of thousands of bioinformatics tools.
- WDL & CWL
- Open workflow standards for portable, interoperable pipelines.
- Git & GitHub
- Version control and collaboration at the centre of every project.
- GA4GH standards
- Interoperability specifications for genomics data and tools.
- FAIR principles
- Findable, accessible, interoperable, and reusable by design.
- Semantic versioning
- Predictable release versioning so updates never surprise your team.
Choosing a Workflow Manager
Nextflow vs. Snakemake vs. WDL
There is no single best manager—only the right one for your team and infrastructure. A quick orientation; we will help you decide.
| Dimension | Nextflow | Snakemake | WDL |
|---|---|---|---|
| Language | Groovy-based DSL2, dataflow | Python-based rules | Declarative, tool-agnostic |
| Model | Channels & processes | Works back from target files | Tasks & workflows |
| Ready pipelines | Large nf-core library | Snakemake workflow catalog | Broad (Terra, Dockstore) |
| Runs on | Local, HPC, all major clouds | Local, HPC, cloud | Cromwell / cloud platforms |
| Best suited to | Cloud-scale, production pipelines | Python teams & HPC research | Portable, platform-based workflows |
What You Receive
A complete, documented deliverable
Not just a script that works on one machine—everything your team needs to run, trust, and extend the software.
- Version-controlled repository with the pipeline or software
- Containers & pinned environment files (Docker / Apptainer / Conda)
- Automated tests & continuous-integration configuration
- Run configurations for your HPC or cloud infrastructure
- A small test dataset for quick validation
- Documentation, usage guide & a handover session
- Semantic-versioned releases for predictable updates
Built for reproducibility, not just a result
Every build follows software-engineering best practices—modular design, per-step containers, automated tests, and continuous integration—so the pipeline runs the same on your laptop, your cluster, and the cloud, and keeps working as tools and data change. We separate workflow logic from execution configuration, so moving between infrastructures is a config change, not a rewrite. Everything ships version-controlled and documented.
The practical payoff: your methods section writes itself, a reviewer can re-run the analysis, and a result from today can be reproduced a year from now. We will also tell you honestly when a design or sample size won't support the conclusion you're after.
FAQ
Pipelines & software questions
What research and platform teams most often ask before starting a build.
End-to-end analysis pipelines (for example genomics, RNA-seq, or single-cell), custom command-line tools, R and Python packages, data-processing and ETL systems, and web apps or dashboards — from a one-off script to a production workflow your team runs routinely.
Both. Nextflow (with nf-core) suits cloud-scale, production pipelines; Snakemake fits Python-centric, file-oriented work on HPC. We recommend the one that matches your infrastructure and team, and can also work in WDL or CWL.
Yes. Because we separate workflow logic from execution, the same pipeline runs on a laptop, a SLURM cluster, or AWS, Google Cloud, or Azure. We set up the configuration and, if you like, the infrastructure to run it.
Yes. Each step runs in a pinned Docker or Singularity/Apptainer container (or Conda environment), so the pipeline produces the same results anywhere and doesn't depend on what happens to be installed on a machine.
Yes. We review your current scripts or workflow, then modularise, containerise, add tests, and document it — turning a fragile pipeline into one that is portable, reproducible, and maintainable.
A version-controlled repository with the pipeline or software, containers and environment files, automated tests and CI, run configurations for your infrastructure, and documentation so your team can run and extend it.
Related
What pipelines power
Have a pipeline to build or scale?
Tell us your organism, data type, and question—we'll scope it honestly, including if a different design would serve you better.