Construct assembly

A construct is an ordered argument: this promoter, driving this coding sequence, stopped by this terminator, in this host, for this reason. Written as a flat sequence file, the argument disappears and only the string survives — which is how a design that made perfect sense in March becomes unreadable by September.

The builder keeps the structure. You compose the construct visually, part by part, and pydna models the assembly underneath: simulating the join, tracking what each junction looks like, and flagging the ones that will not work before you have committed anything to an order sheet. The record that comes out is SBOL — a standard that stores parts, roles and relationships rather than a single undifferentiated sequence.

Parts, in an order. Promoters, coding sequences, terminators, selection markers, targeting signals and tags come from the parts library, filtered to the host you have chosen so the list you are picking from is a list of things that will plausibly work. Your own sequences drop in alongside them — a coding sequence from an earlier project, an annotated GenBank upload, or a catalog record pulled in by ID.

Then you say how the pieces join. Pick an assembly method, set the overlaps or restriction sites, and the engine takes it from there. Nothing about the layout is guessed on your behalf, which is deliberate: the builder is a place to be explicit, not a place to be surprised.

Reference set

Founding ten peppers

Constructs

25

Designed length

31,911 bp

Catalog total

1,000 constructs, 14.1 Mbp

Assembly model

pydna

Exports

SBOL, GenBank, FASTA

Engine class

CPU

Credit cost

Free

Typical runtime

Seconds; longer multi-part assemblies under a minute

The founding ten peppers are the set everything else was measured against: twenty-five constructs totalling 31,911 base pairs. That is a small enough body of work to read end to end in an afternoon and complete enough to exercise every decision the builder makes. Open one, see how its parts are ordered and why its junctions sit where they do, then clone it and change a single thing — it is the fastest route into the tool.

The same builder produced the rest. One thousand constructs across 65 organisms, 70 series and six tiers, from the Pepper tier through Tier 5, covering 14.1 Mbp of designed DNA. Scale did not require a different method, only the same one applied consistently.

An SBOL record of the assembly, a GenBank file with the annotation attached, FASTA when plain sequence is all that is wanted, and a vendor-ready order sheet when the design is finished enough to buy. Because SBOL is a standard rather than a house format, the record opens in other people’s tools — the practical test of whether a design is genuinely portable.

Ag-biotech teams use the builder to keep a cultivar programme’s designs in one consistent shape. Pharma groups use it because the versioned, provenance-carrying record is the kind of artefact that survives review. Educators use it because the visual track makes the anatomy of a construct obvious in a way a sequence file never will. Assembly is a CPU engine and runs free; credits are spent elsewhere, on the GPU work that decided what was worth assembling.