# What comes in and goes out on a connection

Source: https://docs.tightly.io/help/settings/what-comes-in-and-goes-out-on-a-connection
Reviewed: 2026-09-07

## What it is

A connection has two halves, and the connection's own page shows both.

One half is what the source feeds Tightly: sets of records, a row each, drawn from Products,
Inventory, Sale orders, Suppliers, Purchase orders, Lead times, Accounts, Locations, Channels,
Sell-out, Shipments and Orders. The other half is what the source reads back out of Tightly:
writes, a row each, drawn from Purchase orders, Stock levels, Product data, Bills, Credits,
Invoices, Fulfilment requests, Acknowledgements, Shipping notices, Availability, Notifications and
Purchase-order events.

Beneath the two halves sit the fields the source actually sent, and the history of everything that
has happened on the connection: syncs, imports, mapping changes, scope changes, dictionary changes, drift, fields
added and removed.

Which sets and which writes appear at all is the source's answer, not a preference. A set the
source cannot send has no row. The one exception is a set somebody switched on that the source has
since stopped sending: it keeps its row, reads `Not offered`, and carries the reason on hover.

## How Tightly decides it

The figures under the page's name count off the table beneath them: Reads, how many sets Tightly
reads, which appears once a set is turned off; and Fields, how many of the fields Tightly knows for
those sets are mapped.

Nothing on the page works a time out for itself. A write Tightly recorded prints the day it
happened; a write nobody recorded reads `Not dated` rather than borrowing the day some other record
changed, and a record with nothing in it yet reads `Nothing written yet`. Counts read the same way:
a number nothing counted reads `Not counted`, never a zero.

Fields come from what arrived in the runs Tightly kept, not from a list of what a source could send
in theory, which is why the fields card appears only once Tightly has kept one run.

## The words on the face

**Feeds Tightly** names the half that comes in and **Reads from Tightly** names the half that goes
out. On the list of connections, Reads from Tightly is also a filter and a kind.

A set's **Reads** cell says `On`, `Off`, `Off · recorded` where the choice is kept but the sync
does not filter yet, or `Not offered`. Its **State** says `Not started`, `Syncing`, `Synced` or
`Failed`, with the reason on hover.

A field's **Use** cell says one of four things: `Mapped to Fabric` where something reads it, `Could
feed Supplier lead time` where Tightly recognises it, `Left as you asked` where somebody turned it
down, and `Not used`.

## What you can do about it

**Stop reading** a set, from its row. Where the source's sync asks per set, Tightly skips it from
the next sync, deletes nothing it has already read, and the cell reads `Off`. Where that sync does
not filter sets yet, Tightly records the choice, says so before you press, and the cell reads
`Off · recorded`. **Read again** puts it back. A read-only seat sees the rows and not the switch.

**Match the fields** opens the mapping wizard at that set.

**Add a field to Tightly**, on a field the source sends that nothing reads yet. Name it, choose its
type, and choose whether it belongs to the product or to one variant. The drawer says what becomes
true before you press: the field lands on every product or variant, the source fills it from the
next sync, and nothing plans by it. Press **Add the field**. An admin's press puts it live; a
member's waits in Review.

A field a source fills is that source's. Editing its value on a product answers where you pressed:

> Fabric is read from Shopify; change it there, or stop reading it on the Shopify page.

Stop reading it, which is an admin's act, and the values stay and become yours to edit.

## Glossary line

A connection's two halves are what a source feeds Tightly and what it reads from Tightly, each a
table of rows on that connection's own page.