Cotton traceability: from module to bale

Tracing cotton means keeping an unbroken line between the round module the picker drops in the field and the lint bale that leaves the gin with a GS1 code. In practice, it comes down to three records tied together: the module, created with its field, variety, date, and GPS position; the pickup, which is the load that carries the modules and gets weighed on arrival; and the bale, which points back to its source module. Once those links are in place, a code sold months later leads back to the field that produced that lint — and, in the other direction, each module’s weight becomes that field’s yield.

This guide walks through the whole path: what each step records, the mistakes that cost the most, and what traceability gives back the following season. The topic is in the spotlight with the 15th Brazilian Cotton Congress, September 22–24, 2026, in Belo Horizonte — upCampo will be at booth 21.

Why trace

Cotton traceability is no longer just internal control; it has become part of the sales conversation. Fiber certification programs require proof of origin, and buyers want to know which field produced the lint they’re contracting. A system that only knows how many bales left the farm can’t answer that.

But the most concrete reason comes before the market. In cotton, weight doesn’t arrive with the harvest: the picker leaves the module in the field, and the number only shows up on the gin’s scale days later. Without a chain linking that weight to the module, the field, and the variety, the farm ends the season knowing the total harvested but not which area produced what.

Traceability solves both problems with the same work: the record that proves origin to the outside world is the same one that produces yield per field on the inside.

The complete path

Step	Where it happens	What is created there
Harvest	Field	The module: code, field, variety, date, GPS, picker
Pickup	From the field to the gin	The load: truck, driver, date, and the modules on board
Weighing	Gin scale	Gross weight, tare, and tarp — and from there, each module’s weight
Check	Unloading	Confirmation that the modules reported are the ones that arrived
Ginning	Cotton gin	The bale: lint, cottonseed, linters, trash, and the GS1 code
Sale	Invoicing	The invoice built on the weight already recorded

Each row depends on the one before it, which is why this work can’t be left for the end: a module without a field won’t turn into yield later, no matter how accurate the weighing is.

What each step records

The module is created in the field — without a weight

The cotton module is the unit of cotton traceability. Each one is a record with a code, season, field, crop, variety, date and time it was created, picker, format, shift, latitude, and longitude.

It is created without a weight — in cotton, the module exists as a traceable object before it exists as a quantity. The weight comes with the pickup.

It can be recorded in three ways: in the app, with the technician logging the module as soon as the picker drops it and attaching a QR code label; manually in the portal; or through the John Deere picker integration, which brings modules in from Operations Center with module ID, hectares, and operator, with no typing. One setting comes before all of this: the crop must be marked with the “Permite fardos” (allows modules) option, or the field won’t even show up on the screen.

The pickup is the load — and it’s what provides the weight

The module pickup is the load that carries modules from the field to the gin. Since harvest produces many modules and hauling happens a little at a time, each trip is a pickup: a document with the source area, destination, truck, driver, date, and the modules on board. It is usually built in the app as the load comes together, and the loading order is recorded so unloading can be checked in the same sequence.

On arrival, the loaded truck is weighed and, after unloading, the tare is weighed. The load’s net weight is gross minus tare minus tarp, and that net weight is split evenly across the modules in that pickup. In a hypothetical load of 12 modules with 24,000 kg net, each module gets 2,000 kg.

Two consequences follow from this rule. Don’t mix modules from different fields in the same load if you want accurate yield per field, because both fields would get the average weight. And the count must be right before weighing: one module too many or too few changes the weight of all of them. A module that already arrives with its own weight, from the picker through the integration, isn’t overwritten — the split only fills in the ones without a weight.

Once finalized, the pickup is locked for editing, with a record of who finalized it; if a correction is needed, the same button reopens the document and the change stays traceable.

The check happens after the scale

When the truck arrives, there’s no time to check module by module. That’s why the check is a separate step, done at unloading: it confirms that the modules reported in the app are the ones that arrived and stores the status of each module and who checked it. Until then, the load stays pending on the list — the indicator of how much of the production hasn’t yet been matched against the gin.

The bale closes the line

The bale is the lint bale that comes out of ginning, with the seed already removed. It’s the bale that carries the GS1 code, and it’s the bale that is sold and invoiced — and each one points to its source module. Once the module is selected, field and variety fill in automatically and are locked: this is exactly where traceability stops depending on data-entry discipline.

The record separates the net lint weight — what counts in the sale — from the gross weight and tare, as well as cottonseed, linters, and trash, plus the ginning lot, visual grade, and press. When the gin reports turnout as a percentage, these weights are filled in all at once from it.

From there on, the sale uses the weight already recorded, with no re-entry, and the invoice columns show what has shipped and what is still in inventory.

The mistakes that cost the most

Module with the wrong field. This is the most expensive of the three, because it’s wrong twice: the field that produced it comes up short on yield, and the one that didn’t gets extra. When it happened across an entire shift, it can be fixed in bulk, without opening module by module.

Mismatch between the farm’s weight and the gin’s weight. The weight recorded at the farm and the weight checked at the gin are stored separately, and the difference between them points to losses in transit, a burst module, or an out-of-calibration scale. If only one number is kept, there’s no mismatch to find — just a number you have to accept.

Module left behind in the field. It happens every year, and the cost isn’t just the lost cotton: a module that isn’t picked up doesn’t go into any load, so it gets no weight, so that field’s yield comes out lower than it really was. GPS position solves this — modules show up on the map to plan the pickup route, and the list shows which ones are still in the field.

A fourth, quieter mistake: creating modules in bulk without a tracking code. They count for weight and area, but they can’t be traced by scanning — the chain to the bale breaks right there, and nobody finds out until someone needs to prove origin.

What traceability gives back

Added up by field, module weights make up the total harvested and the average yield in the season planting record, in arrobas per hectare (1 arroba = 15 kg) — with no one typing anything. And since each module carries its variety, the same total answers by cultivar: which variety performed best in which area and on which planting date.

That’s what changes the next plan: cultivar placement is no longer decided by the farm’s average result but by each field’s result, which is where the difference shows up.

The same record completes the cost picture. With crop operations logged in work orders with inputs, area, and execution, as in up.Operações, cost per field meets yield per field in the same place. The full view of what the platform covers in cotton runs from scouting to lint sold, and the contract terms are on the pricing page.

Frequently asked questions

How do you trace a cotton module in practice?

By attaching a QR code label as soon as the picker drops it and recording its code, field, variety, date, and GPS position. The code is scanned later, at pickup and at the check, and it’s what links the module to the lint bale at the end of the line.

Is the module weighed in the field?

No. The module is created without a weight and gets one at pickup, when the truck carrying it is weighed at the gin. A module that already arrives with its own weight, through the picker integration, keeps that weight.

How is each module’s weight calculated?

The load’s net weight is the gross weight minus the tare minus the tarp, and that value is split evenly across the modules in that pickup.

What’s the difference between a module and a bale?

The module is the round module the picker leaves in the field. The bale is the lint bale that comes out of ginning, with the seed already removed — it’s the one with the GS1 code, and it’s the one that gets sold. Each bale points to the module it came from.

What is the GS1 code on the bale for?

It’s the identification standard in the cotton market: each lint bale gets a unique code that follows it through sale and storage. Keeping it together with the source module is what lets you start from a buyer’s code and get back to the field that produced that lint.

How is yield per field calculated?

By adding up the weights of the modules from each field. Since each module gets its weight from the load split and carries its field and variety, the total per area builds the harvested amount and the average yield, and the same data answers by cultivar.

The field doesn’t show up to receive modules. What’s missing?

The crop must be marked with the “Permite fardos” (allows modules) option in the crop setup. Without it, the field isn’t available in this feature, even if it’s registered and has planting recorded.