Case study: custom software
A DNA design platform, run end to end by machine learning
Paste a protein. Get a synthesizable gene, scored by AI and checked by two independent RNA engines.
Codon optimization decides how much protein a gene actually makes. This platform treats it as a machine-learning problem: it drafts candidate genes, scores every codon against a foundation model, validates the RNA structure, and checks the result against real synthesis vendors. We designed and built it for a client working in genomics.
The science
Why codon choice is a real problem
Optimizing a gene isn't cosmetic. The same protein can be written billions of ways, and the wrong encoding can sink an experiment. This is the tool that picks the right one.
The problem
One protein, countless ways to encode it
Cells read DNA three letters at a time, and most amino acids have several synonymous codons. Which ones you choose decides how much protein a gene makes, sometimes the difference between an experiment that works and one that quietly fails.
- Legacy tools lean on frequency tables and manual, codon-by-codon edits
- The best choice depends on the organism, the RNA fold, and the synthesis vendor at once
- Get it wrong and a gene expresses poorly, or can't be manufactured at all
The platform
A design IDE, not a lookup table
We built a browser-based genomic design environment that treats optimization as machine-learning-scored search. A scientist goes from a raw protein to a ranked, validated, synthesizable gene without leaving the page.
- Multiple optimized candidates, each scored by a foundation model
- RNA structure validated by two independent engines
- Manufacturability checked against real vendor rules before export
- Plasmid maps, a genome browser, and a code editor, all in one screen
The engine
The life of a sequence
Six things happen between a pasted protein and a gene ready for synthesis. A scientist can watch every one, or just take the answer.
A protein comes in
A scientist pastes a protein or an existing gene into a browser-based editor. The platform validates it against the twenty amino acids, parses annotated GenBank and FASTA uploads, and pulls the right codon-usage table for the target organism. E. coli and human are built in; any other species is fetched live from public databases by its taxonomy ID.
Six strategies draft the gene
Five optimization strategies run in parallel, each with a different priority: maximum expression, a balanced blend, RNA-structure-first, codon-pair bias, and protein stability. A sixth, ML-enhanced pass uses the foundation model. Every strategy is grounded in peer-reviewed codon science, not a single frequency table.
A foundation model scores every codon
Each candidate gene is scored by NVIDIA's CodonFM, a foundation model with variants up to a billion parameters, running on GPU. It assigns a per-codon fitness using delta log-likelihood and an overall sequence fitness on a zero to one hundred scale, so a design can be ranked, not just generated.
Two RNA engines check the fold
The messenger RNA's folding energy is computed with ViennaRNA. When two candidates are close, or confidence is low, a second engine, RNAstructure, is triggered automatically and the two are cross-checked for agreement. Every result is cached by content hash, so the same sequence is never folded twice.
Risky regions get flagged, with fixes
A sliding window finds the stretches most likely to hurt expression and returns ranked synonymous swaps for each one. A large constraint engine screens for restriction sites, repeats, homopolymers, and out-of-range GC, then rewrites the sequence to satisfy real synthesis vendors' rules, so what comes out can actually be ordered.
It lands in a design IDE
Results open in a genomic IDE in the browser: a SnapGene-style plasmid map, an IGV genome browser with a click-to-apply track of better codons, a fitness heatmap, and a before-and-after comparison. Scientists export the final gene as FASTA or JSON and take it to synthesis.
Under the hood
The parts we're proud of
A foundation model, not a chatbot
The ML earns its place on the critical path. CodonFM scores the actual DNA, per codon and per sequence, flags the regions most likely to hurt expression, and ranks the synonymous codons that would fix them. It also emits sequence embeddings, so designs can be searched and compared by similarity, not just by text.
Two RNA engines that check each other
Folding predictions disagree, so the platform never trusts just one. ViennaRNA runs on every sequence for speed; RNAstructure runs as a second opinion when the call is close or low-confidence, and the two are scored for concordance. Trust comes from cross-validation, and a content-addressed cache keeps it fast.
Optimization as multi-objective search
Real designs balance goals that fight each other. A Pareto optimizer weighs ML fitness against GC content, RNA structure, codon adaptation, and manufacturability all at once, and a large constraint engine rewrites sequences to be synthesizable. The output is optimal and orderable, not one at the cost of the other.
A genomic IDE in the browser
Bench scientists expect real tools. This ships a Monaco code editor with a custom DNA language, an IGV genome browser, SnapGene-style plasmid maps, Plotly analytics, direct NCBI fetch, and click-to-apply codon swaps, all on one screen. No desktop install, no jumping between apps.
Why it matters
Built on real science, not a frequency table
Legacy codon tools pick the most common codon and stop. This platform scores every design against a billion-parameter model, validates the RNA structure with two independent engines, and checks the result against real synthesis vendors, so the gene that comes out is orderable, not just optimal on paper.
This was a build engagement, start to finish. No growth campaign attached, and that's exactly how most clients hire us: one service at a time.
Built to be operated
The unglamorous parts that keep it honest
- Degrades gracefully, never dies. Capability flags gate every optional dependency. If an ML model or a folding engine isn't present, the pipeline falls back to a simpler method instead of failing, and a lite mode runs the entire interface with no GPU at all.
- Cross-checked, then cached. The expensive second RNA engine runs only when the first one's call is close or uncertain, and every result is cached by content hash with a seven-day expiry, so the same sequence is never paid for twice.
- Tested like it's going to be used. Hundreds of automated tests across the Python backend and the React apps, a multi-part QA plan, and continuous integration that runs backend, unit, build, end-to-end, and lint checks on every push.
- Documented as it was built. A dated engineering changelog runs alongside the code, including a line-by-line audit of the machine-learning integration, so anyone can see how it was assembled and roll any single piece back.
Stack
Serious tools, sensibly chosen
Have something ambitious in mind?
Tell us what you want built. Within 48 business hours you'll get a written plan and a fixed quote, no sales call. Complex, research-grade, ML in the loop: that's the kind of build we like most.
Get a build quoteDetails anonymized. NVIDIA CodonFM, ViennaRNA, RNAstructure, and the synthesis vendors referenced above are integrations and tools, not clients.