Sequencing Verification

Answer the question a sequencing result is meant to answer: does this clone match the intended construct.

What it doesCopy Anchor Link

You designed a construct. You sent it away, and something came back. This tool tells you whether the two are the same molecule, and if they are not, exactly what differs and whether it matters.

It answers that question in two ways, because there are two different things a sequencing provider might have sent you.

Reads grades individual sequencing reads against the construct you expected. Each read gets a status — verified, near, partial or divergent — with its identity, how much of the target it covers, and how many mismatches and gaps it carries. This is the mode for a handful of Sanger reads, where each one covers a few hundred bases and no single read sees the whole plasmid.

Construct compares one whole finished molecule against the design. This is the mode for a whole-plasmid sequencing result: the provider assembled every read into a single consensus, and the question is no longer "do these reads support my construct" but "is this the plasmid I drew". It reports every difference at its position on your design, what each one does to each annotated feature, and how much of the design the result actually covers.

When you'd use thisCopy Anchor Link

Used in: Clone an insert into a vector, and prove it worked · Design a CRISPR guide, check where else it binds, and measure the edit you got

You have built something and you want to know if it worked. The route depends on what you had done to it.

• Whole-plasmid sequencing came back. Open your design, switch to Construct, and give it the consensus. This is the common case now that whole-plasmid nanopore sequencing costs a few pounds per sample.
• A few Sanger reads came back, covering a junction or an insert. Use Reads. Each one is graded separately, because a single read that covers a third of your plasmid at 99% identity tells you about that third and nothing about the rest — and the grade says so.
• You have traces, not sequences. Read them in the Chromatogram editor first, where you can correct base calls and trim the noisy ends, then bring the corrected reads here.
• A difference turned out to be foreign sequence. Send the result to Screen for vector contamination, which checks it against the vector database rather than against your design.

What this computesCopy Anchor Link

Construct mode — one assembled result against the design

• A banded gap-affine global alignment (Smith-Waterman-Gotoh), with the band measured from where the two sequences correspond rather than guessed; a difference approaching the band's width re-runs the comparison wider and the panel says it did
• Circular framing before anything is compared: the result's strand and starting offset are resolved against the design by a vote over short words across the whole molecule, so a plasmid read from an arbitrary origin is not scored as if it were rearranged
• Every difference in its unique left-aligned, parsimonious representation (Tan, Abecasis & Kang, Bioinformatics 2015), so the same real mutation gets the same coordinate in two runs — checked byte for byte against bcftools
• A Sequence Ontology consequence per difference — missense, synonymous, stop gained, stop lost, start lost, frameshift, in-frame insertion or deletion — with the most severe per feature chosen by Ensembl's published ranking, and translated under the genetic code the record itself declares
• An Ensembl IMPACT severity class (high / moderate / low), plus an explicit unknown class for a coding sequence whose genetic code the record never declared — off that scale on purpose
• Frame-breaking decided from the net length change of the whole event, so a clean three-base deletion is an in-frame deletion rather than a false frameshift
• A per-feature verdict — did this gene survive — reported before the base-level table, including not verified as a distinct verdict from changed for a feature sitting over uncalled bases
• Uncalled bases counted separately from differences, with how many of them disagree with the designed base even so, because an uncalled base is missing information rather than a changed one
• Repeated sequence in the molecule, counted and said in its own words, because that is where a difference is hardest to place

Reads mode — many reads against an expected sequence

• A short-read alignment with free end gaps, so a read covering part of the construct is not penalised for the part it does not reach
• A grade per read against a bar that is visible and yours to move, with the coverage each read contributes and the target's own name carried into the caption and the exported report
• Topology taken from the fetched record, so a read spanning the origin of a circular target is rotated into frame rather than cut in half
• Which of the two gates a read missed, stated in words — a grade is decided on identity and on coverage, and the same grade means opposite things depending on which one fell short. A read that agrees with the reference but does not span it is missing sequence: the bases it never reached are ungraded rather than confirmed, and the answer is more sequencing. A read that spans the reference and disagrees with it is a real difference, and the answer is at the bench. The reading says which, names the read it is talking about, and quotes both numbers
• What the verdict for the whole target rests on — the target takes the grade of its best read, so the reading says how many of the reads actually stand behind it rather than letting one good read speak for four bad ones
• The bar and the trimming that produced the numbers, carried with the answer: identity and coverage both move when either is changed, so a reading that did not name them could not be checked by whoever receives it

What it does not compute: a pass/fail verdict for a whole construct. No published standard for grading one exists, and inventing a threshold would dress a preference as a result. Large rearrangements are reported, not classified — an inversion or a tandem duplication appears as a long insertion beside a long deletion, which is what a pairwise alignment can honestly say about it.

Reading the coverage a provider sends backCopy Anchor Link

A whole-plasmid sequencing provider returns more than a consensus: a per-base table of how many reads aligned at every position. The QC tab reads it, and reads it as a shape rather than as an average, because an average has none — a run at 200× with one uncovered region reads as excellent.

A real 56,219-position depth track. The panel reports the median and the range, then the two things an average cannot show: the longest stretch under the line, with its coordinates and its floor, and the largest change in level, with the position it happens at. Here the coverage line has been raised to 30× from the provider's 20×, and the reading says whose line it is.

The one number the provider publishes is that coverage over ~20x indicates a very accurate consensus. That is their sentence, quoted as theirs, and it is the line the panel starts at. It is also a control you can move: a construct headed for a deposit is held to a higher bar than one being checked on the bench, and raising the line changes every count and every stretch beneath it.

The two shapes they warn about are a large gap, or a sudden large increase — either can mean an assembly problem or a mixture of more than one plasmid in the tube. Both are measured and located:

What the tool will not do is tell you how large is too large. The provider does not publish that number, and no other source does. Inventing one would be presenting a threshold nobody set as though it were established, so the shapes are measured, named and located, and the judgement stays yours. Where a threshold is published — the 20× line — it is used and attributed.

Where it livesCopy Anchor Link

Tools → Sequencing Verification, in the right-hand rail. It acts on whatever construct is open, so the design is the document you are looking at; the result is the thing you supply.

Selecting a difference in the report selects that base on the map, so the linear and circular views scroll to it and the surrounding annotations are visible. Selecting a feature selects the whole feature.

Inputs and outputsCopy Anchor Link

The design is the open construct. Its topology matters and is read from the record: a circular design is compared as a circle, so a result that starts at a different base is still recognised as the same molecule.

The expected sequence, in Reads mode, is normally the construct you have open. It does not have to be. Fetch it straight from a public repository — NCBI Nucleotide, ENA, UniProtKB, the iGEM Registry, Addgene or EBI Dbfetch — and grade your reads against a published record without leaving the panel or hunting for a file first. Three things follow from the record itself rather than from a default, and they matter:

• Its name travels with the answer. The target bar, the coverage caption and the exported report all read pSB1C3, not expected sequence, so a report you paste into a notebook says what it was graded against.
• Its topology sets how reads are graded. A record that declares itself circular is compared as a circle, so a read that spans the origin is rotated into frame instead of being cut in half and scored twice as badly as it deserves. Fetch a plasmid and you get plasmid grading, without choosing anything.
• Edit the sequence by hand and the record's name goes away. That is deliberate: a report headed with an accession over bases you have since changed would be a provenance claim the data no longer supports.

If the fetched record is a protein, or the file comes back with nothing usable in it, the dialog says which record and why, and stays open — reads are graded in bases, and a protein sequence would produce a plausible-looking table of nonsense.

The result can be pasted, uploaded, or picked from the files already in your project. Any sequence format the workbench reads is accepted — the format is detected rather than assumed, so a GenBank file is parsed as GenBank and its annotations are available.

What comes back, in the order you need it: the headline numbers, then what happened to each annotated feature, then the table of individual differences, and the two aligned rows around whichever difference you select. The per-feature view comes first deliberately — did my gene survive is the question, and a table of base positions is the evidence for the answer rather than the answer. The differences export as a table.

Two things are counted apart from the differences and said in their own words: positions the sequencer could not call, and repeated sequence in the molecule, where a difference is hardest to place.

What it refuses, and what it says. Each refusal names the shape of the mistake, not just the fact of it.

• A result far shorter than the design is a read, a primer or a fragment, and it says so — "that looks like a read, not a whole construct" — and points you at Reads mode. This is checked first, because it is the more specific diagnosis.
• Two sequences sharing no words at all are refused outright; that is almost always the wrong pair of files.
• A result covering too little of the design is refused with both coverage figures quoted and both readings offered: either these are not the same construct, or the clone has lost more than half of it.
• No construct open is its own message rather than an empty panel: the design is the sequence this compares against, so there is nothing to compare until one is open.

There is a third case that is deliberately not a refusal. A result that covers most but not all of the design gets its answer plus a warning, because refusing there would hide a real finding: a clone that genuinely lost a kilobase looks exactly like a mildly wrong file, and only you can tell which you are holding.

DemoCopy Anchor Link

Silent, 12 seconds, recorded on the Sequencing verification sample project. The open target is the 3,049 bp reference cf-M13-ref.fa. Add read files lists the traces already in the project; picking B5-M13R_B07.ab1 (1,141 bases) grades it at once. The verdict is Partial: the coverage bar shows one read spanning only part of the 3 kb target, and the read is drawn on the map as matched runs followed by the stretch it never reached. Nothing is uploaded; the trace is read in the browser.

Worked exampleCopy Anchor Link

The Sequencing verification sample project carries everything this walkthrough needs: two real yeast loci that differ by a whole marker cassette, and two real circular vectors that share only part of their ancestry.

1. Open the construct you designed. In the project's file list, open FAS2_KanMX4_locus.gb — one yeast FAS2 locus, 3,613 bp, linear, carrying a KanMX4 selection cassette. This is the design: the molecule you believe you built.

2. Switch the panel to Construct. Reads mode grades short traces against a target; Construct mode compares one finished molecule against another. The header confirms what it is acting on and its topology before you choose anything.

3. Choose the result. From project, pick FAS2_NatMX4_locus.gb — the same locus with a different marker knocked in. The panel states the pair it is about to compare, with both lengths, so a mis-picked file is visible before the run rather than after.

4. Read the verdict. The report comes back 306 differences at 93.848% identity, with 74.9% of the design and 81.8% of the result covered by exact matches, above a warning that these may be related constructs rather than the same one. That warning is correct and is the point of the example: these two molecules differ by an entire cassette.

5. Read what it did to each gene. The per-feature summary is where a number becomes a decision. KanR shows 283 differences with 245 bases missing and a frameshift consequence, because in the NatMX4 version that gene is not there at all — a different marker occupies the slot. loxP and kanMX are flagged not fully covered, which is a different statement from changed: part of them was never seen.

6. Look at the molecule. Every difference is drawn on the map as it is found, in its own lane directly above the features, so the shape of the disagreement is visible without reading a single row: here the marks pile into one dense band over kanMX and KanR and leave the rest of the locus clean, which is what a swapped cassette looks like and what 306 scattered sequencing errors would not. Show on map turns the lane off when you want to read the molecule without it.

7. Follow one difference down to the bases. Selecting a row in the table selects that base on the molecule and opens the two aligned rows around it, design over result, so the boundary of the swapped cassette can be read base by base.

8. Ask a mark on the map what it is. Right-click any difference and it answers in place: the position and the change, what it does to the protein in the authority's own words and colour, which annotated features it falls inside, and the span it just selected. From there you can copy that one difference in the same columns as the full export, or copy it as HGVS, which is the notation to paste into a paper, a plasmid map note, or the email to whoever made the clone.

How a difference is written in HGVSCopy Anchor Link

Every difference also carries its name in the Human Genome Variation Society's sequence-variant nomenclature, written against your own record's name: fas2__KanMX4:g.2251_2261del. The g. prefix is linear-reference numbering, which is what applies to a plasmid: it counts bases from position 1 of the molecule you are comparing against, and it takes any accession, so a construct's own name is a valid reference. The transcript-relative c. form is deliberately not offered, because it numbers from a start codon relative to a transcript accession that a plasmid record does not have, and inventing one would put a made-up identifier into a variant name people cite.

Two conventions are worth knowing, because they are where the numbers differ from what the table shows. HGVS names only the bases that changed, so an eleven-base deletion whose table row is anchored at position 2,250 is written g.2251_2261del — the anchor base is still in your clone. And an insertion is written between two positions (g.1042_1043insGGA), never at one, because the inserted bases have no coordinate of their own on the reference.

An uncalled base gets no HGVS at all. Where the sequencer returned an ambiguity code, there is no variant to name: HGVS describes a change, and N is the instrument declining to say whether there was one. Writing it as a substitution to N would assert a base that does not exist, so the copy item is simply absent on those marks and the position stays in the uncalled count.

Did it pass?Copy Anchor Link

The panel will state a verdict, and the rule behind it is not ours. Addgene — the repository most of the field deposits into — publishes the acceptance rule it applies to every plasmid it receives:

A sample passes automatically on a 100% nucleotide match to base identity and plasmid length. Any mismatch or indel goes to manual review, where a QC issue is a discrepancy believed to affect the function of the plasmid: point mutations, frame shifts, missing elements, and nucleotide indels or mismatches in significant plasmid elements.

Both halves of that map onto what the comparison already computes. The first is the identity and length you can read in the numbers above; the second is exactly what the per-feature view answers.

There are two outcomes, and neither of them is "fail". A clone either passes automatically or goes to manual review, because the standard's own second step is a person deciding whether a discrepancy matters. A tool that printed FAIL over a silent codon change in a backbone spacer would be asserting something the rule does not say. What you get instead is the list of what this run found, in the standard's own categories, and the per-feature evidence underneath it.

You can decline the standard. Choose None and the panel reports the numbers and says nothing about acceptance — which is the right answer if your lab has its own rule, and many do.

Uncalled bases are counted apart from mismatches. A position the sequencer could not read is missing information rather than a discrepancy, so it never appears as a mutation. It is equally not a 100% match, so it is named as its own reason for review.

On regulatory standards, since people ask. USP General Chapter 〈1040〉, Quality Considerations of Plasmid DNA as a Starting Material for Cell and Gene Therapies, exists — but it is an informational chapter rather than an enforceable one, it addresses GMP manufacturing rather than bench cloning verification, and its text is not publicly available. Nothing here is derived from it, and no threshold in this tool claims regulatory standing.

One event, or three hundred differences?Copy Anchor Link

A table of individual differences answers what changed. It does not answer what happened, and on a real cloning failure those are different questions with very different answers. Swap a KanMX4 cassette for a NatMX4 one and the comparison reports 306 differences — every one of them real, and none of them saying the thing a bench scientist actually needs to hear, which is that one cassette was replaced by another.

Structural events answers the second question. Where the difference table walks the alignment base by base, this reads the junctions between aligned blocks and asks what single event explains each one. For the cassette swap above it reports a single line: a repeat contraction of 237 bases at 1,480–2,280 — one event, in the place the marker sits.

The six kinds, and what each one is telling you. They are separated by the signature two adjacent blocks make, not by size:

Events are drawn on the molecule, in their own lane. A structural event is a span, not a position, so it appears as a labelled bar directly above the individual differences and above your own features: the event summarises, the differences are its detail, the features are what it happened to. Right-click one and it tells you the kind, what that kind means, the span it selected, and whether it is one of the large ones flagged for inspection.

Two size thresholds, and both are yours to move. They decide what counts as an event at all, so they are on the panel rather than buried. The lower one (50 bases by default) sits below any cassette and above the small indels the difference table already reports one base at a time; raise it to see only the large rearrangements, drop it to catch a short linker duplication. The upper one (10,000 bases) is where a "structural event" stops being a plausible cloning outcome and starts being two unrelated molecules; a BAC or a whole-genome comparison wants it raised. Anything past it is still reported, in its own group marked inspect by hand — those are usually assembly artefacts, but they can be real translocations, and a comparison that quietly dropped its largest finding would be worse than useless.

An inversion is seen and deliberately not reported. A flipped block is visible in the signature, but two blocks alone cannot separate a genuine inversion from a molecule the assembler joined the wrong way round, so nothing is claimed about one. The panel says how many junctions were classified and withheld rather than staying silent about them, so you know the difference between "no inversion here" and "not asking".

When there is nothing to say, it says that too. Two molecules that share only one matching block have no junction to classify at all, which is a different answer from "no events found" — and the panel prints that sentence instead of an empty table.

Every event exports as a tab-separated table alongside the difference table, with the reference, both gap sizes and the matching coordinates on your result.

The same question on a plasmidCopy Anchor Link

Open PBR322.gb and compare it against L09137.gb (pUC19). Both are real circular cloning vectors, and they share their ampicillin-resistance gene and origin of replication but little else.

The answer is the one a whole-plasmid tool has to be able to give and is the hardest to get right: 1,226 differences at 75.554% identity over 51.3% of the design. That is neither "the same molecule" nor "nothing in common", and the panel says so in those terms rather than reporting a number that could be read either way. On a circular map the differences draw as a ring outside the features, and the arcs where pUC19 genuinely matches pBR322 are visibly bare.

What a clean clone looks likeCopy Anchor Link

The verification project carries the honest version of this case rather than a construct compared against itself. Open L09137.gb — pUC19, the design — and compare it against M77789.gb, which is the same vector sequenced independently by a different group and deposited on the opposite strand, starting from a different base. Nobody told the tool that. It has to work it out.

It does, and the verdict is the one you want to see: no differences, 100.000% identity, both molecules 2,686 bp, every annotated feature intact. Against Addgene's rule the construct passes automatically.

Read the Result orientation box: "reverse complement · starts at design base 685". Two molecules that are letter-for-letter identical can be written down in completely different ways, and a comparison that skipped this step would have reported a plasmid that shares almost nothing with its own design. Nothing is drawn on the map, because there is nothing to draw — that is the answer, not an empty view.

The near miss — the one that actually happensCopy Anchor Link

A clean pass and an unrelated plasmid are the easy ends. The failure you will really meet is a construct that is almost right, and the classic is picking the wrong vector off the bench. Compare the same pUC19 design against L08752.gb — pUC18, which is the identical backbone with the polylinker built in the opposite orientation.

25 differences at 99.291% identity, both molecules 2,686 bp. Better than 99% identical, the same length, and completely wrong for your cloning: 24 of the 25 fall between positions 396 and 454 — the multiple cloning site — so the restriction sites you were counting on are in the reverse order. The twenty-fifth is a single A→G at position 1,308, well outside the polylinker.

Addgene's rule sends this to manual review rather than failing it, and the panel names the standard's own categories for what it found — missing elements, nucleotide indels. It will not tell you whether that matters, because that judgement is the depositor's; it tells you exactly what changed and leaves the call to you.

This is the pitfall worth taking away: identity alone would have called this a good clone. 99.3% looks like sequencing noise. It is not — it is 24 real events packed into the 60 bases you care about most, plus one lone base a thousand positions away. A single percentage cannot tell those two apart, which is why the tool reports where every difference is and paints them on the map. Switch the canvas to the linear view and the shape of the answer is immediate: a dense block at the polylinker, and one isolated tick.

What it refusesCopy Anchor Link

Hand it a sequencing read instead of a finished construct and it does not produce a report full of meaningless differences. It says the pair cannot be compared and why:

The refusal names the mistake rather than the symptom. These two share no 16-base word on either strand, so no alignment between them would mean anything, and reporting one would be worse than saying nothing.

ControlsCopy Anchor Link

• Mode — Reads or Construct, described above.
• Target — the open construct, or an expected sequence you paste. Reads mode only.
• Topology — circular or linear. It follows the open construct and can be overridden, which is what you need when the target is pasted and carries no topology of its own.
• Result source — paste it, or choose a file. Choosing opens your project's own sequence files with a preview, and imports one from disk if it is not in the project yet, so the sequence you compared against is a file you still have afterwards rather than bytes read once and dropped.
• Contamination acceptance tier — the residual host-DNA percentage you are willing to accept, for provider QC files that report it. Research and GMP tiers are offered because the acceptable level differs by two orders of magnitude between them.
• Show on map — whether the differences are drawn on the molecule. On by default, because the distribution is usually the finding; off when you want the map back. The marks are a view of the comparison and are never written into your file, so they are not in an export and do not survive a reload.

Grading a read: the bar, and where it sitsCopy Anchor Link

Every read in Reads mode gets one of four grades, and the bar that decides them is a control, not a fixed rule:

Five numbers set those boundaries, and they open under Grading thresholds beneath the report: the ungapped identity and coverage a read must reach to be verified, how many gaps a verified alignment may contain, and the identity and coverage floors for near. They start at the values the method was published with, and one click puts them back.

They are yours to move because the bar is a lab decision, not a fact about the molecule: a screening run and a therapeutic release do not accept the same read. Everything in the panel follows what you set — the grades, the summary verdict above the table, the legend beneath it, and the header of the exported report, so a file you hand to someone else says which bar produced its numbers.

What moving one actually does, on the five reads this tool ships with. Graded at the published bar, one read of the M13 reference comes back 99.3% identity over 35.7% coverage and is called partial — high agreement, not enough of the target seen, which is what a single Sanger read of a 3 kb construct looks like. Drop Near · coverage from 80 to 30 and that read becomes near, while the other four do not move: their coverage is 4.1–20.4%, still under the new floor. The legend rewrites itself in the same moment, from "at least 80% coverage" to "at least 30%".

That is the whole point of the bar being a control. Nothing about the molecules changed — identity, coverage, mismatches and indels are all exactly as they were. What changed is the question you asked of them, and the panel makes the new question visible rather than quietly re-grading behind a number you cannot see.

A single verdict for the construct sits beside the report heading — the best-graded read, and how many stand behind it. Five reads that all say partial is a different situation from five reads of which one says verified, and the table alone makes you work that out.

Trimming reads before they are gradedCopy Anchor Link

The ends of a Sanger read are where the basecaller runs out of signal, and those miscalls are real mismatches as far as any alignment is concerned. Grading them drags the identity down and can push a perfectly good read out of verified. Three choices, under Trim reads before grading:

• None — grade exactly what the machine called.
• Mott — the trace file's own end-trim, the same one the chromatogram editor shows. Needs an ABI trace; a pasted read or a non-ABI file is graded whole and the panel says so rather than pretending.
• Quality window — trim until a window of consecutive bases averages above a quality floor. Both the window length and the mean Q floor are yours (Q20 is one error in a hundred bases, Q30 one in a thousand). Note that a sliding window stops where the window mean crosses the floor, so roughly half a window of the poor stretch survives at each end; shorten the window if you want a tighter cut.

Trimming is never destructive. The reads keep their full base calls, only the copy being graded is cut, and the selected read shows exactly which bases were used: graded bases 16–1140 of 1141. The exported report records which trim produced its numbers, for the same reason it records the bar.

On five real Sanger traces of an M13 reference, Mott trimming takes one read from 109 mismatches to 37 without changing a single base of the read itself. That is the size of the effect, and it is why an untrimmed grade is worth distrusting.

Where a read actually landedCopy Anchor Link

The coverage bar under the report shows how much of the target a read reached. The map shows which part — the selected read's matching, mismatching and gapped stretches are drawn along the molecule in the linear, circular and sequence views, in the same three colours as the bar.

This is the question a single read is really asked. A read covering 35% of a 3 kb construct at 99% identity has told you about a third of it; whether that third is the insert you cloned or the backbone you already trusted is the whole point, and no percentage can say.

Comparison settingsCopy Anchor Link

Nine parameters govern the comparison, and all nine are yours. They sit under Comparison settings on the panel, start at the values the method was validated with, and re-run the comparison the moment you change one. A count of how many you have moved sits beside them, with one click to put them back.

Most runs never need them. They matter when a molecule or a sequencing result is unusual, and that is exactly when a fixed value would quietly give you the wrong answer.

Anchoring — how the two molecules are lined up before anything is compared.

• Anchor word size (default 16 bases) — the length of the exact matches used to work out strand and starting point. Longer is more specific and finds fewer anchors on a result that has drifted; shorter anchors a noisy consensus at the cost of chance matches. Raise it on a molecule full of repeats, lower it on a low-quality read-through.
• Band margin (default 32 bases) — how far outside the anchored path the alignment is allowed to look. Raise it when you expect an insertion or deletion the anchors do not bracket.

Refusal thresholds — when the tool declines to answer.

• Shortest result accepted (default 20% of the design) — below this the input is treated as a read rather than a construct, and you are told to grade it in Reads mode instead of being handed hundreds of meaningless differences.
• Refuse below coverage (default 35%) — the hard floor. Below it, the two molecules are reported as not the same construct. The number is measured rather than chosen: on real vectors, an unrelated plasmid covers about 23% of pBR322, while pUC19 — which is built from pBR322's origin and ampicillin resistance — covers 51%.
• Warn below coverage (default 80%) — between this and the floor you still get every difference, with the caveat that these may be related constructs rather than the same one. A real clone that lost a whole kilobase still lands above it, which is why the two thresholds are separate: one number cannot both refuse a stranger and report a real deletion.

Scoring — what the alignment is optimising.

• Match score, Mismatch score, Gap open, Gap extend (+1, −1, 1, 1) — the aligner's own defaults, and the values every reference comparison was checked against. Making the mismatch harsher makes the aligner prefer a gap, so single-base changes start being reported as an insertion beside a deletion; raising the gap costs does the reverse. Change them and you are asking a different question, so the alignment score is on the panel beside the identity: it is the number these four move, and comparing two settings without it means comparing two alignments by eye.

All nine parameters, with anchor word size at 24 and refuse below coverage raised to 60%. The pBR322-versus-pUC19 pair covers 51.3%, so at a 60% floor the tool declines to compare them and says so in the user's own terms: "covered by matching 24-base words, below the 60% floor". The chip reads Reset 2 changed, which is how you always know whether you are looking at the defaults.

Every number on screen comes from the run. Nothing is a default you cannot see.

Algorithms you can chooseCopy Anchor Link

This tool offers one alignment method, and the reason is worth stating rather than hiding.

A whole-plasmid comparison is between two sequences that are meant to be identical. That is a much easier problem than general sequence alignment, and it admits an exact answer: a banded gap-affine global alignment, which finds the optimal alignment provided the true one stays within a band around the diagonal. The band is not guessed — it is measured from where the two sequences actually correspond, and if a difference approaches the width of the band the comparison is re-run wider and the panel says it did. Offering a choice of aligner here would be offering a choice of being wrong.

Reads mode uses a different alignment because it is a different problem: a short read against a long target, with free end gaps, so that a read covering part of the construct is not penalised for the part it does not reach.

The scienceCopy Anchor Link

Alignment. Gap-affine global alignment, in the Smith-Waterman-Gotoh formulation, restricted to a band around the correspondence between the two molecules. Gap-affine means a long gap costs an opening penalty plus a per-base extension, which is the model that treats a single twelve-base deletion as one event rather than twelve — the biologically right answer, since that is how deletions arise.

Circularity. A plasmid has no origin; the base a sequencing pipeline calls position 1 is arbitrary. Before anything is compared, the result's strand and starting point are resolved against the design by matching short words across the whole molecule and taking the offset the most bases agree on. This is a vote rather than a single anchor, so scattered sequencing errors cannot defeat it — in testing, forty substitutions scattered through a 4,361 bp plasmid still recover the exact offset.

How differences are written down. A deletion inside a homopolymer, or of one unit of a tandem repeat, can be written at several positions and mean the same thing — and plasmids are full of both. Every difference is therefore reduced to the unique left-aligned, parsimonious representation defined and proved unique by Tan, Abecasis and Kang (Bioinformatics, 2015). Without that step the same real mutation gets different coordinates in two runs of the same tool. Our output is checked against bcftools, byte for byte, on real plasmid sequence.

One case has no upstream convention, because no variant tool has a concept of a circular reference: a difference that would shift left past the origin. We stop at the origin and never wrap the alleles, and say so on the record. A wrapped allele cannot be written in VCF or GenBank, and wrapping would make the coordinate depend on the arbitrary starting point the frame step exists to remove.

What a difference does to a gene. Differences inside a coding sequence are classified with Sequence Ontology terms — missense, synonymous, stop gained, stop lost, start lost, frameshift, in-frame insertion or deletion — using the ordering Ensembl publishes, so the most severe consequence in a feature is picked by a published ranking rather than by our judgement. Translation uses the genetic code the record itself declares, and a coding sequence that declares none is reported as changed without a consequence rather than translated on the standard code, which would give the wrong amino acid for a bacterial or mitochondrial gene without saying so.

The colours on the map. A difference is drawn in the colour of the worst thing it does to an annotated gene, and the four severity classes are not ours: they are the IMPACT rating Ensembl assigns each consequence term, read from its own reference implementation and cross-checked against its published table. High means the protein is broken — a frameshift, a lost start, a gained or lost stop. Moderate means the protein changed but is still a protein. Low is a silent change, which is reported rather than hidden because a synonymous substitution can still sit in a ribosome-binding site. The fourth class is deliberately off that scale and means the impact is unknown — most often a coding sequence whose genetic code the record never declared. A difference outside every annotated feature, and a base the sequencer could not call, each get their own colour again, because neither is a statement about a protein. The palette itself is colour-blind safe, and every colour on screen is beside its own name.

Whether an insertion or deletion breaks the reading frame is decided from the net length change of the whole event, not one base at a time. A clean three-base deletion is an in-frame deletion, not a frameshift — that is what the Sequence Ontology definition says, and reporting otherwise would be a false alarm on a perfectly good clone.

Bases the sequencer could not call. A real consensus carries N, and other ambiguity codes, wherever coverage or agreement was too low to choose a base. These are counted separately from differences and carry no consequence, because an uncalled base is missing information rather than a changed one. The panel says how many there are, and how many of them disagree with the designed base even so. A feature sitting over such a stretch is reported as not verified, which is a different statement from changed.

Shared with other tools: Read quality compares how every tool that does this chooses its method.

LimitationsCopy Anchor Link

• There is no pass or fail for a whole construct. Construct mode reports what differs and ranks severity by a published ordering; it does not tell you whether your clone is acceptable. No standard for grading a construct exists that we could find, and inventing a threshold would be dressing a preference as a result. Decide your own rule and apply it to the numbers shown. Reads mode is different: individual reads are graded, against a bar that is published, visible and yours to move — see Grading a read above.
• Large rearrangements are reported, not classified. An inversion, a tandem duplication or a recombined backbone appears as a long insertion beside a long deletion, which is what a pairwise alignment can honestly say about it. It will not be named as an inversion. These are real cloning failures and this is the tool's weakest answer.
• The comparison is between two sequences. If the result was assembled badly, the tool compares your design against a bad assembly and cannot know. Coverage figures from the provider, where supplied, are the check on that.
• A close relative can look like a mutated clone. Plasmids share modules by descent — pUC19 shares about half of pBR322 by exact matching, because it is built from the same origin and resistance gene. The coverage warning exists for this, but it is a warning and not a proof.
• Both molecules must be the same kind of thing. Comparing a whole plasmid against a single short read is refused; use Reads mode for that.

Compared with other toolsCopy Anchor Link

Not yet written. Every comparison row needs a first-party source with a retrieval date, and that research has not been done for this tool.

ExportCopy Anchor Link

The difference table exports as a tab-separated file: position on the design, what kind of difference it is, the designed and observed sequence, the length change, which features it falls in, its consequence, and its HGVS name. Reads mode exports its graded report the same way.

The HGVS column is empty for uncalled positions, for the reason above. The notation is checked against the reference parser the nomenclature's own maintainers publish, so a name copied out of here parses where you paste it.

APICopy Anchor Link

Not documented while the surface is experimental and its shape can still change.

AutomationCopy Anchor Link

Not yet available for the Construct mode. Reads mode can hand its graded reads to the vector contamination screen, and that screen is available as an automation step.

ProvenanceCopy Anchor Link

The run is not yet recorded in the document's version history — the comparison reads the design and does not modify it, so nothing is written back. Export the difference table if you need a record.

ScreenshotsCopy Anchor Link

The Construct-mode figures are in the walkthrough above, where the steps they illustrate are. These two are Reads mode, which that walkthrough does not cover.

As it opens, on the Sequencing verification sample project: the mode switch, the target it is acting on, and the ways to bring reads in.

Reads mode, after a run. The reference checked against itself is the only ✓; B5-M13R_B07 is the matched read at 99.3% identity over 35.7% coverage — high identity over part of the construct, which is what one Sanger read of a 3 kb target looks like — while the reads of other templates land at 74–77% with a hundred or more mismatches each. The grade is driven by coverage first, which is why they read ~ partial rather than ✗ divergent.

RelatedCopy Anchor Link

In this group: Chromatogram · Map reads to a reference · Fragment analysis · Alignment · Variant Calls · Population genetics: allele frequencies, Hardy–Weinberg, Fst, linkage disequilibrium · RNA-seq: differential expression with DESeq2, over-represented gene sets, gene set enrichment · Multiple Sequence Alignment · Compare Traces to Reference · Screen for vector contamination

Feeds it: Chromatogram — correct and trim traces before grading them here. Follows it: Screen for vector contamination — for a difference that turns out to be foreign sequence.