# Variants Desk

> A deliverables list is a cross-product. THE WORK IS NOT. Five ratios, three languages and two
> cutdowns is thirty files - everybody gets that far - but the edit is per duration and nothing else,
> the crop is per duration and ratio, the master is per everything. The work is a SUM OF SMALLER
> PRODUCTS over only the axes each task depends on: forty-eight units, not thirty and not a hundred
> and fifty. Five lanes over one axes-and-tasks sheet, plus a free browser-side factorisation engine.

URL: https://variants-desk.skillsafe.ai/
API: https://variants-desk.skillsafe.ai/api.html

Derived from heygen-com/hyperframes (https://github.com/heygen-com/hyperframes), Apache-2.0: a
toolkit for building video compositions, title cards, overlays, captions and voiceovers.
Not affiliated with or endorsed by heygen-com.

## The arithmetic

```text
deliverables      = product of every axis size
units per task    = product of ONLY the axes that task depends on
work              = sum of units, over the tasks
naive count       = deliverables x number of tasks      <- what a spreadsheet does
```

People get this wrong in BOTH directions: thirty, because there are thirty files; or a hundred and
fifty, because there are five tasks and thirty files. Give both numbers and the gap, every time.

## Blast radius

Change one instance of one task and what it invalidates is exactly the product of the axes that task
does NOT pin down.

```text
re-cut one duration       edit is per duration     -> ratio x language = 15 masters
re-record one mix         mix is per duration+lang -> ratio            =  5 masters
re-render one master      master is per everything ->                  =  1
```

One multiplication, and nobody computes it. BLAST RADII DO NOT ADD - two changes whose sets overlap
lose the overlap once, and adding them over-states the damage.

## Matrix hygiene

- An axis nothing depends on multiplies the file count and adds no work. Either it is not an axis
  (platform often is not, when the same file goes to three of them) or a task is missing a
  dependency - and the second is far more common and far more expensive.
- A misspelt dependency is silently dropped, so that task's count comes out low. It is the one error
  here that makes the answer look BETTER rather than worse, which is why it survives review.
- Two tasks over the same axes are one pass per combination rather than two.

## The flat matrix

Every task depending on every axis is not a plan, it is a spreadsheet - what one-row-per-file
produces. It costs tasks x files, the maximum the job could take. Do not correct the arithmetic; the
arithmetic is right. Ask of each step which axes it genuinely varies with. The answer is usually one
or two.

## Units are not time

Everything here is exact arithmetic over supplied numbers - no estimate, no model, no rate. A unit is
one run of one task. A master render and an offline edit are both one unit and are not the same
afternoon, which is why the answer is in units rather than in days.

## The sheet

```text
AXES
ratio    | 16:9, 9:16, 1:1, 4:5, 21:9
language | en, de, ja
duration | 60s, 30s

TASKS
edit     | duration                  | the offline cut
crop     | duration, ratio           | reframe each cut for each shape
master   | duration, ratio, language | the render
```

The middle field of a task is its dependency set and it is the entire input to every number on the
page. An empty middle field means the task depends on nothing and is done once.

A matrix cannot express "ratio, but only for one of its values". When one value needs different
work, model it as a second task over a two-value axis and say so.

## The lanes

- `plan` - turns a delivery brief into axes and a pipeline
- `check` - gives both numbers and says which quote is wrong, and in which direction
- `factor` - works out what each step genuinely varies with, and why the other axes are off
- `impact` - costs a change before anybody agrees to it, overlap subtracted
- `schedule` - orders the passes so tasks over the same axes are one pass

## What it does not do

It renders nothing and schedules nothing. Every figure is arithmetic over numbers you supply, so it
is only as good as the dependency sets you write.