Execution and Data Management

Run a step and Pointy ties the execution to one specific committed workflow state. Status, logs, and output files stay attached to the producing step and that revision, so the exact state can be inspected and, when shareable, linked later. This section follows that lifecycle: starting and stopping work, inspecting outputs, comparing results, and sharing findings. It also covers uploaded inputs and repository-backed source files.

Running derivation steps

Derivation steps expose a Run button. Clicking it asks the backend to build the selected step together with any upstream dependencies it requires. The build uses a Git-pinned version of the user repository, so every run corresponds to one precise, committed workflow state.

A derivation step row showing the Run button alongside the step status indicator and other step actions.

Step statuses

Pointy marks every step with a status dot in its row. You'll see six distinct states:

Not Started: the step exists but has not produced a successful output yet
Running: the backend is currently building the step
Success: the build finished successfully and output files are available
Failure: the build failed. Hover the dot to see the last meaningful line from the build log when available; click it to open the build log popover.
Loading (unknown): the status is not yet known; a spinner is shown with no dot behind it
Loading Running: the step was just started and Pointy is waiting for the backend to confirm it is running. The yellow Running dot shows behind the spinner.

Status changes are pushed to the browser automatically, so you do not need to refresh the page while waiting for a build.

A project view with step status indicators visible in the left column; these update automatically as backend status events arrive.

Shareable states

Running and successful steps are shareable; failed steps are not. Being shareable means the UI exposes inspect, clone, and share actions for that particular step state; successful steps additionally expose share actions on their output entries. The distinction preserves access to an in-progress or completed configuration without presenting a failed build as a result. See Building Workflows (Steps) for the corresponding editing operations.

Stopping a running step

While a step is running, a Stop button appears in the same control area as Run. Stopping the step cancels the active build so you can adjust the step and run it again.

A derivation step row while the step is running, with the Stop button hovered in the execution control area.

Uploading files

File-upload steps expose Upload files instead of Run. The template determines which file extensions the picker accepts.

You can submit one or more files at a time, follow the transfer progress, and cancel an upload in progress. A single submission accepts at most 100 files; larger sets should be packaged as a zip archive or divided among several file-upload steps.

Once transfer finishes, Pointy immediately builds the upload step, which then follows the same Running / Success / Failure lifecycle as a derivation.

A file-upload step row showing the upload-oriented controls used for input steps.

Browsing output files

Successful steps expose an Output Files browser in which folders can be expanded, supported formats previewed inline, and files downloaded. Sharing operates at the same granularity as inspection: you can link to the complete output, a folder, an individual file, or a selected range of lines in a previewed text file.

The output files browser open on a script step, showing an expanded output folder with a previewed hello file displaying its Hello World content.

For text outputs, drag in the line-number gutter to select one or more lines before sharing. Pointy highlights the selected range, updates the URL with a lines= query parameter, and the file's Share action copies a commit-pinned link to that exact range. Recipients land on the same file with the selected lines highlighted.

Large text files (over 5 MiB) aren't loaded in full for preview. Instead, Pointy fetches a seekable window of about 2 MiB around the requested position.

As you scroll near the top or bottom of the window, Pointy prefetches the adjacent chunk so the visible neighbourhood stays seamless without loading the entire file into the browser.

The Download action always retrieves the complete file regardless of size.

HTML outputs support both:

inline preview rendered in a sandboxed iframe, with Zoom In and Zoom Out controls
Open in new tab, which opens a commit-pinned artifact page

The artifact page (at /artifact/<project>/<step>/<commit>?path=…) serves the requested HTML together with any relative CSS, JavaScript, and images from the same pinned step-output bundle. The page renders in a full-window sandboxed iframe and includes a View in Pointy link that returns to the project and output context.

The output files browser open on a fastqc step, showing chim_R1_fastqc.html previewed inline with its FastQC Report content visible alongside the other output files.

CSV and TSV grid preview

Files ending in .csv or .tsv (and files served with the matching MIME types) render as a sortable, filterable data grid instead of the plain text preview.

The grid gives you a spreadsheet-like experience right in the browser: sort columns, filter values, and resize headers without leaving Pointy. Use the viewer-mode button to switch between Grid viewer and Regular viewer. The regular viewer preserves the original delimited text and line-number gutter; line-targeted links open in that mode so the selected lines remain visible.

Each column has:

a header you can click to cycle ascending → descending → unsorted
a filter input below the header
a draggable right-edge handle for resizing

The filter input recognises four modes per column:

foo: case-insensitive substring match
=foo: exact match (case-insensitive)
<5.3 / >5.3: numeric comparison; columns that fail to parse as numbers fall back to lexical comparison
an empty filter shows all rows

When the step's template publishes typed column metadata, columns are treated as Int, Float, or String for filtering and sorting, and the header tooltip shows the declared type and nullability. Without that metadata every column is treated as a string column. See Injecting typed column metadata via extras for the template-author side.

Metadata is fetched lazily, per folder, when you expand it. The first time you open a folder of a step whose extras have not been built yet, Pointy enqueues the extras build in the background; subsequent visits pick up the typed columns once the build finishes. The grid stays usable in the meantime, just with string-typed columns.

A samples.csv output rendered as a delimited grid inside a step's Output Files section, with column headers carrying filter inputs above multiple data rows.

Source files

Some derivation templates enable Source Files, in which case Pointy shows that section even while its directory is empty. It identifies the srcFiles/<step-id>/ directory, the repository URL, and the branch the files come from. You can browse, download, and share existing source files down to a selected range of text lines. This facility is controlled by the template and instance configuration rather than by the individual user; see Setting Up the User Repository to enable it for a step type.

A step showing the Source Files section with an expanded directory view of the srcFiles directory from the user repository.

Comparing files

You can compare any file that Pointy can preview. Click Compare on the first file, then pick a second previewable file from the same browser or another output/source browser. While Pointy is waiting for the second file, a comparison banner stays visible; use Cancel there if you picked the wrong first file.

The compare selection banner shown after choosing the first output file.

After the second file is picked, Pointy opens a comparison dialog and records the comparison in the browser URL. Copy that URL if you want to reopen the same comparison later. Output-file entries include their output commit in the URL; source-file entries point at the current source-file browser entry.

The comparison dialog adapts to the file type:

text files are shown side by side, with differing lines highlighted
CSV and TSV files use the same sortable, filterable grid preview as the normal file browser
images render as image panes
HTML output files render in sandboxed preview panes

For derivation-step outputs, each side can also show the step parameters that produced that file, and the Open source in project action jumps back to the original file in context.

The compare dialog showing two output files side by side.

Shareable steps, shareable output entries, and selected source-file line ranges expose a Share action.

A share link:

opens the project in a read-only view
pins the page to a specific Git commit
can deep-link to the step itself, to a specific output file or folder inside it, or to selected lines inside a previewed output or source text file

Line-targeted links open with the requested line centred and the selected range highlighted. This is what makes share links stable: the recipient sees the version of the workflow state that the link was created for, not whatever happens to be current later on.

The read-only banner includes a View current version link when you want to leave the pinned view and go back to the live project.