How to Move Into Computational Biology From the Wet Lab

Moving from the wet lab into computational biology works best when you re-analyse data you generated yourself, in one scripted language, instead of starting from a tutorial dataset. Choose the language from your research goal, keep the analysis out of spreadsheets, and turn each bench skill into a documented, rerunnable artefact.

Most advice for bench scientists who want to compute starts and ends with “learn Python”. That is the smallest part of the problem. The part nobody writes down is that you already hold the asset a computer-science graduate does not: your own data, your own protocol, and a question you understand well enough to know when an answer is wrong. This guide is about converting that asset, in four moves.

The StemSkills Lab team has spent more than ten years in sequence and structural bioinformatics, drug discovery and design, and multiscale molecular modeling, working with students who arrive from exactly this direction. The route below follows the peer-reviewed guidance written for your situation rather than general coding advice.

Why is “learn Python first” the wrong place to start?

Because a language is a tool, and you pick a tool from the job. The canonical primary source here is Carey and Papin, Ten simple rules for biologists learning to program (PLOS Computational Biology 2018, 14(1):e1005871, PMID 29300745). The authors state their audience plainly: “We write these 10 simple rules for traditionally trained biologists, particularly graduate students interested in acquiring a computational skill set.”

Their opening argument is the one that matters for a transition decision. Cores and collaborators can run an analysis for you, but “the computational literacy required to design and interpret omics studies cannot be replaced or supplemented”. You are not learning to program so you can compete with software engineers. You are learning so that the design and the interpretation of your own study stop being outsourced.

Rule 1 of that paper is “Begin with the end in mind: When picking your first language, focus on your goal.” It then lists the goals that lead to different answers: becoming a programmer, designing bioinformatics tools, implementing existing tools, or simply getting your data analysed. The paper is explicit that “there is no universal ‘best’ language”.

Which language should you learn first?

Answer: the one that the people asking your biological question already use, weighted by what you want to do with it. Table 1 of Carey and Papin discusses eight languages with their key features, and the table below reorganises that discussion by goal. Every “good for” and “not good for” entry comes from the paper’s own descriptions, not from opinion.

Two practical notes the paper makes that are easy to miss. First, if many people in your field use one language, that is evidence it suits the problems you will meet. Second, cost is a real criterion: free languages are “more amenable to open source work”, which matters if you want your analysis to be shareable and citable later. For a bench biologist in a molecular or structural group, that usually resolves to Python plus enough shell to move files and run tools, and that is the pairing our computational biology skills roadmap sequences.

What should your first computational project actually be?

Your own bench data, re-analysed end to end in a script. Not a tutorial dataset, not a Kaggle table. This is the move that separates a wet-lab candidate from every self-taught applicant, because the output is simultaneously a lab result and a portfolio artefact.

Do it in the order Rule 8 of Carey and Papin prescribes: “Use toy datasets to practice a problem or analysis” and “Generate small toy datasets that use the same structure as your data.” The reason given is sharp and it is a wet-lab reason: “Toy datasets are your negative control, allowing you to differentiate between negative results and simulation failure.” You already think in controls. Apply that habit to code.

A worked example: a plate reading, done properly

Here is the smallest honest version. A nine-row toy file with the same shape as a real plate export, including one well that failed to read, saved as toy_plate.csv:

sample,condition,replicate,od600
A1,control,1,0.412
A2,control,2,0.389
A3,control,3,0.401
B1,treated,1,0.204
B2,treated,2,0.198
B3,treated,3,
C1,blank,1,0.043
C2,blank,2,0.041
C3,blank,3,0.045

And the script, using only the Python standard library so there is nothing to install:

import csv
from statistics import mean, stdev

rows = []
with open("toy_plate.csv", newline="") as fh:
    for r in csv.DictReader(fh):
        raw = r["od600"].strip()
        if raw == "":
            print(f"warning: {r['sample']} has no reading, excluded")
            continue
        rows.append((r["condition"], float(raw)))

blank = mean(v for c, v in rows if c == "blank")
print(f"blank mean = {blank:.4f}")

for cond in ("control", "treated"):
    vals = [v - blank for c, v in rows if c == cond]
    sd = stdev(vals) if len(vals) > 1 else float("nan")
    print(f"{cond:8s} n={len(vals)} corrected_mean={mean(vals):.4f} sd={sd:.4f}")

Run with python3 summarise.py, it prints:

warning: B3 has no reading, excluded
blank mean = 0.0430
control  n=3 corrected_mean=0.3577 sd=0.0115
treated  n=2 corrected_mean=0.1580 sd=0.0042

Look at what the script did that a spreadsheet would not have done for you. It announced the failed well instead of quietly treating an empty cell as zero, and it printed n=2 for the treated condition so the reduced replicate count travels with the number. That is a control you built, and it is the same instinct you already use when a lane on a gel looks wrong. Once this runs on toy data, point it at your real export and the analysis is reproducible from raw values by anyone, including you when you come back to it later.

From there, scale the same pattern rather than the ambition: one dataset you own, one question, one figure, one command that regenerates it. If you want project shapes that finish, our guide to computational biology project ideas for MSc students lists archetypes, and the bioinformatics portfolio guide covers how to publish it so it can be checked.

Why does the spreadsheet-plus-tool hybrid have to go?

Because it is the single habit that keeps a transition stuck, and the primary source names it. Rule 3 of Carey and Papin is “Immersion is the best learning tool”, and the instruction is direct: “Don’t stitch together an analysis by switching between or among languages and/or point and click environments (Excel, etc.). While learning, if a job can be done in one language or environment, do it all there.”

The paper then explains the failure mode you will actually hit. Spreadsheets guess how to read text, and that guess differs from the conventions of other languages. Blank cells may not arrive as blank or NA, numbers can arrive quoted as text, column names can be lost. When the import looks wrong, the temptation is to go back to the spreadsheet and fix it with search and replace. The paper’s verdict on that loop: “In addition to slowing the learning curve, transferring across programs induces error.”

So the rule for your first year of scripting is narrow and worth following literally. Read the raw file in your language, inspect the types on import, fix problems in code, and never edit the raw file. Rule 7 extends the same discipline to record keeping: “Computational research is research, so use your best practices”, including a computational lab notebook, because “Computational protocols are scripts, and these should include the code itself and how to access everything needed to implement the code.” You already keep a notebook. Keep this one the same way.

What is a wet-lab background worth in computational biology?

It is worth the judgement that the field cannot generate from data alone, and there is a public number that shows why. UniProtKB, the reference protein knowledgebase, exposes its record counts through its REST API. On release 2026_03, dated 2 September 2026, a size-zero search returned 150,006,383 total entries against 575,748 reviewed ones, which is under 0.4 percent manually curated. You can re-derive today’s figures yourself from the x-total-results response header:

curl -sD - -o /dev/null "https://rest.uniprot.org/uniprotkb/search?query=*&size=0" | grep -i x-total-results
curl -sD - -o /dev/null "https://rest.uniprot.org/uniprotkb/search?query=reviewed:true&size=0" | grep -i x-total-results

That gap is the argument for your background. The overwhelming majority of protein records are computational predictions awaiting a human who knows what a plausible result looks like. Someone who has run the assay knows which controls were missing, what a noisy readout looks like, and which output is biologically impossible rather than merely surprising. That is not a soft skill. It is the step where most published analyses fail.

The field says so formally, too. The ISCB Curriculum Task Force paper, Mulder and colleagues, The development and application of bioinformatics core competencies (PLOS Computational Biology 2018, PMID 29390004), records that its original three user profiles “were too narrow and did not adequately capture the breadth of roles requiring bioinformatics competency”. The expanded set explicitly includes “physicians, lab technicians, ethicists and biocurators, scientists (which include the discovery biologist, academic bioinformatics researcher and core facility scientist)”. If you have wondered whether the field has a category for you, that sentence is the citable answer. Its Table 1 of sixteen core competencies, labelled A to P, is also the most useful checklist you can measure yourself against, and our guide to the skills you actually need for a computational biology job walks through it.

How do you turn a bench skill into a line someone can check?

By naming the computational equivalent and pointing it at evidence. A claim in a CV is only worth the artefact behind it, which is the format our bioinformatics CV guide sets out. Use that format rather than inventing a new one.

A before and after, in the CV guide’s format, with placeholder numbers you would replace with your own. Before: “Familiar with data analysis and Python.” That claims a state of mind and points at nothing. After: “Re-analysed 96 growth-curve readings from my own MSc assay in a Python script with blank correction and explicit handling of failed wells; output regenerates from the raw export with one command (repository link).” The second version names the data, the method, the edge case, and where to look. Notice it claims nothing about how long it took.

When the call comes, the four assessments you will face are not one assessment, and our guide to bioinformatics interview and coding-test preparation separates them. The parsing test in particular rewards exactly the habit the plate script above builds.

Where do wet-lab transitions go wrong?

Four failures come up repeatedly, and each has a concrete fix.

The tutorial loop: courses finish, nothing exists

Symptom: several completed courses, no output anyone can look at. Cause: tutorial datasets are pre-cleaned, so they never force the decisions your own data will. Fix: stop enrolling and re-run one analysis you already understand on data you own. The Software Carpentry lessons and Data Carpentry are good material precisely because they are lesson material, not a credential to collect. Rule 10 of Carey and Papin is blunt about the starting problem: “Just start coding. You can’t edit a blank page.”

The round trip: the file gets opened in a spreadsheet “just to check”

Symptom: results change between runs and nobody can say why. Cause: manual edits to raw data leave no record. Fix: treat the raw export as read-only, do every transformation in code, and print the row count before and after every filter so silent losses become visible. That is what the warning: B3 has no reading line in the worked example is for.

Asking a public dataset a question it cannot answer

Symptom: weeks of work, then the metadata turns out not to record the variable you need. Cause: a question chosen before the metadata was read. Fix: before committing, download the sample metadata alone and confirm the grouping variable exists and is populated for enough samples. The EMBL-EBI training pages cover the archives and their metadata models, and Biopython’s documentation covers programmatic retrieval once you know what you are retrieving.

Installing everything system-wide until something breaks

Symptom: a tool upgrade breaks an unrelated analysis, or your script stops working after a laptop update. Cause: one shared environment for every project. Fix: one environment per project from the start, installed through Bioconda or, for R packages, Bioconductor, with the environment file committed alongside the code. When you later chain tools into a pipeline, Nextflow’s documentation is the standard next step. If you want pure syntax practice in parallel, the problems at Rosalind are self-checking.

Two things this guide deliberately does not do: re-teach Python syntax, and re-teach simulation tooling. When you reach the point of analysing trajectories, our tutorials on plotting GROMACS XVG output in Python and MDAnalysis for trajectory analysis are the hands-on continuation, and the immunoinformatics pillar is a complete project chain if your interest is vaccine design rather than omics.

What is the honest order of operations?

Pick the language from the goal. Re-analyse your own data, toy set first. Keep it in one language and out of spreadsheets. Convert each bench skill into an evidence line. Then, and only then, think about credentials: our free certifications exist to give you something verifiable to attach, and the free bioinformatics certifications guide explains which external ones are actually free to certify rather than only free to learn. If your target is a research degree, the PhD application guide and the route into bioinformatics in India cover what the artefact is for.

Carey and Papin close by quoting Markowetz: “Computational biologists are just biologists using a different tool.” You have used the other tools. This is one more, and the entry ticket is a script that runs twice and gives the same answer.

Frequently asked questions

Do I have to leave the wet lab to do this?

No, and leaving early usually costs you the thing that makes you distinctive. The transition described here is additive: you keep generating data and you start analysing it yourself. The ISCB competency paper’s expanded role set includes lab technicians and discovery biologists for this reason, so bench-based computational work is a recognised position rather than a halfway state.

Should I learn both R and Python?

Not at the same time. Rule 3 of Carey and Papin argues for immersion in one environment while learning, because moving between environments both slows learning and “induces error”. Pick one from the goal table above, get one real analysis finished in it, and add the second language when a specific task requires it.

Is a certificate enough to get into computational biology?

A certificate is verifiable evidence that you completed something assessed, which is useful, and it is not a substitute for an artefact someone can inspect. Use certificates to prove a baseline and a repository to prove judgement. Our guide comparing bioinformatics, computational biology and biotechnology is worth reading first if you are still choosing which of those you are aiming at.

Can I use unpublished thesis data for a public portfolio project?

Check with your supervisor before publishing anything, because the data may be under an embargo or a collaboration agreement. A common solution is to publish the code and a toy dataset with the same structure, exactly as Rule 8 describes, and keep the real data private. The code, the controls and the documentation are what a reader is assessing anyway.

What if I have no programming background at all?

That is the reader Carey and Papin wrote for. Start with the shell commands needed to move and inspect files, then one interpreted language, then one real analysis. Structured lesson material from the Carpentries is designed for researchers in exactly this position, and a supervised project through an internship route shortens the feedback loop considerably.

Which roles should I be targeting while I make the switch?

Roles where domain knowledge is priced in, such as core facility analysis, assay-adjacent data work, and research positions in groups that generate their own data. Our breakdown of bioinformatics career paths and job roles maps them, and the skills roadmap sequences what each one needs.