QGIS draws the map in the office. QField is its field companion, the app that carries the same project onto a phone or tablet so the person standing in the field collects data against the same layers, the same forms, and the same symbology the office designed. The bridge between them is the QFieldSync plugin, and the bridge is where the intelligence lives: QFieldSync is where you decide, layer by layer, what travels, what can be edited offline, and how edits come home. This guide teaches that system: the packaging actions and what each one really commits you to, the cable route against QFieldCloud, form design in QGIS, and the synchronization model that lets a crew's work merge instead of overwrite.
Home / GIS and Open Map Data for Beginners
QField for QGIS: Package the Project, Collect in the Field, Sync It Back

Photo: Mikael Blomkvist / Pexels
Package, Collect, Sync: The QField Checklist
Check off each step as you finish it. Your progress stays on this page.
0 of 7 complete
0% done
The Shape of the System
Three pieces, one project. In QGIS you build the project as usual: layers, styles, forms, print nothing, this project's destination is a pocket. QFieldSync, a QGIS plugin, packages that project for the field: it converts layers as needed, copies or exports the data, and writes the package to a folder (for cable transfer) or pushes it to QFieldCloud. QField, the mobile app, opens the package, shows the map with your symbology, positions by the device's GPS, and collects and edits features through forms. After fieldwork the flow reverses: the package returns by cable, or QFieldCloud synchronizes it, and the changes land back in your QGIS data. Everything in this article hangs off one observation: the field app is the simple part. The decisions are all made at packaging time, in QFieldSync, which is why this guide spends its length there.
The Packaging Actions: Copy, Offline Editing, Remove
For each layer in the project, QFieldSync offers a packaging action, and the choice is the most consequential click in the whole workflow:
| Action | What travels | What comes back | Right for |
|---|---|---|---|
| Copy (directly access the data source) | A copy of the layer as it stands | Nothing; edits in the field stay in the field copy unless handled manually | Reference layers the crew reads but must not change |
| Offline editing | The layer plus a change log | Every field edit, logged, ready to merge into the source | Layers the crew actually collects or corrects |
| Remove from project | Nothing; the layer is dropped from the package | Nothing | Office-only layers: analysis scratch, print aids, anything the field should not carry |
Copy is for context: the basemap-adjacent vectors, the boundary the crew navigates by, the previous survey's results they consult. It is read-only in spirit even where the app would let a stray edit happen, because nothing carries the edit home. Offline editing is for the work itself: QFieldSync prepares the layer so QField records every change against a log, and on return those changes apply to the master data. Remove is the hygiene action, and skipping it is how field packages end up carrying the project's entire attic onto a phone that needed six layers. Choose per layer, on purpose, asking of each: does the field read it, change it, or never see it? The answer is the action.

Why Offline Editing Merges Instead of Overwriting
The offline editing action deserves its mechanism, because the mechanism is the promise. When a layer is packaged for offline editing, the field copy carries a record of the layer's state at packaging, and QField logs the changes made against it: this feature added, that attribute corrected, this geometry moved. On synchronization, the changes are applied to the master layer rather than the field copy replacing it. That is what lets two surveyors package the same project on Monday, work different halves of a site all week without any connection, and both sync on Friday: their change logs touch different features and merge cleanly, where a file-copy workflow would have the second upload silently erase the first. Conflicts are still possible when two people edit the same feature, and the honest handling is procedural: divide the site so crews do not share features, or designate who resolves overlaps. The technology removes the ordinary collision; the crew plan removes the extraordinary one. Every multi-user horror story about field data ends at a packaging screen where someone chose Copy for a layer the crew was meant to edit, or a workflow where packages were copied back as whole files. Choose offline editing for work layers and the horror genre closes.
Cable Against QFieldCloud
The package reaches the device two ways. The cable route is the original: QFieldSync writes the packaged project to a folder, you copy it to the device (or its card) by USB, fieldwork happens, and you copy the folder back and let QFieldSync synchronize the returned package into your data. It needs no accounts and no connectivity, works in the deep field and the secure office alike, and puts the file discipline on you: one package folder per project per round, named and dated like the data it is. QFieldCloud is the hosted route: projects are pushed from QFieldSync to the cloud service, devices pull them down, and synchronization flows back through the service, which also gives a team a shared home for projects and their field status. It suits distributed crews and removes the cable bookkeeping; it asks for connectivity at sync time and an account structure to manage. Neither route changes the packaging decisions above them; they are transport, and the actions you chose in QFieldSync mean the same thing on both. Pick per project: the solo survey an hour from the office rides a cable happily; the five-person crew across a province earns its cloud.
Forms: Designed in QGIS, Answered in the Field
What the collector sees at each feature is a form, and QField renders the form you design in QGIS, in the layer's Attributes Form settings: which fields appear, in what order, with what widgets. Design for the field's realities. Value maps and drop-downs for any field with a known vocabulary, because typing categories on a phone in rain is how "Oak", "oak", and "OAK " become three species in your data. Defaults for the fields that are usually the same (today's date, the surveyor's name, the standard status), so the common case costs zero taps. Constraints where QGIS supports them, so an impossible value is refused at the moment of entry rather than discovered at analysis. Hide the fields the field should never touch (internal IDs, office-calculated columns) rather than trusting collectors to skip them. The form is the data quality strategy, more than any cleaning pass afterward: every error the form prevents is an error the office never has to find. The packaging screen's basemap choices matter here too, and they are the one subject this article deliberately leaves to our QField offline maps guide, which owns basemap preparation inside QField end to end.
A First Field Round, in Order
Put together, a clean first round looks like this. Build the QGIS project with field layers separated from office layers. Design the forms. Run QFieldSync and set each layer's action deliberately: offline editing for the collection layers, copy for reference, remove for the attic. Package by your chosen route and open the package on the device before anyone travels; walk the form on one test feature in the office car park, because every packaging mistake is cheap there and expensive at the site. Collect. Return, synchronize, and inspect the merged data in QGIS against the field notes while the day is still memorable. That loop, run once at small scale, teaches the system better than any documentation, and it scales: the hundredth round is the first round with bigger layers and a crew who no longer need the car park rehearsal. The desktop side of the craft, the toolbox that prepares and cleans what the field brings home, is our processing toolbox guide; the field and the office are one system, and QField is simply where the system goes outside.
Positioning in the Field: What the Phone Knows, and Its Limits
QField positions you by the device's location services, and the map shows your position with its reported accuracy, which the collector should learn to read the way a surveyor reads weather. Under open sky a modern phone places you within a few meters, good enough for the great majority of feature collection: trees, signs, paths, buildings, the whole ordinary inventory of a field survey. Under canopy, in urban canyons, and against cliff faces the fix degrades, and the professional responses are procedural rather than hopeful: wait for the fix to settle before committing the point, collect the feature's geometry by walking its extent rather than trusting one standing position, and record in the form when conditions were poor, because a note about accuracy is data too. For work that genuinely needs better, QField supports external GNSS receivers connected to the device, so a survey-grade or correction-fed position can drive the same forms and layers; the app does not care whether its coordinates come from the phone's chip or a receiver on a pole, which is the architecture's quiet elegance. Match the positioning to the purpose: a playground inventory on phone GPS, a boundary verification on the receiver, and no apology needed for either, as long as the choice was deliberate and the data says which was used.
Battery, Storage, and the Field Day's Physics
A short practical coda, because field systems fail physically more often than logically. A phone running a map, a GPS fix, and a bright screen is spending its battery at the fastest rate its owner ever asks of it; the package discipline from earlier helps (a lean project renders faster and sips less than a bloated one), but the real answers are a power bank treated as survey equipment and a midday charge planned like a fuel stop. Storage follows the same logic: offline packages and their basemaps are sized in the office, where the number is abstract, and felt in the field, where a full device refuses the day's photographs; check the package size against the device before departure, not at the trailhead. None of this is in QFieldSync's dialog, and all of it decides whether the dialog's decisions get a chance to matter. The crews whose data comes home are rarely the ones with the cleverest packaging. They are the ones whose phones were still alive at the last feature.
Related Guides
If this page answered part of the question, these GIS guides cover the rest of the same ground:
- QField Offline Maps: Basemaps Inside QField, Prepared Right: The basemap half of field packaging, owned end to end.
- QGIS Processing Toolbox: Run, Batch, Model, Repeat: Cleaning and analyzing what the field brings home.
- Add GPS Coordinates to QGIS: Points From Files and Devices: The manual route for coordinate data, for readers not yet on QField.
- QGIS Advanced Digitizing: The CAD Panel and Its Keyboard Locks: The office-side precision counterpart to field collection.
- OpenStreetMap on Garmin: Load OSM Maps Onto Your Device, Two Routes: The dedicated-device counterpart to phone-based fieldwork: OSM maps loaded onto Garmin hardware.
- OpenStreetMap ZIM File: The Wiki in a File, and Maps in a File: The offline reference library a field kit carries beside its data collection.
Frequently Asked Questions
What is QField in relation to QGIS?
QField is the mobile field app companion to QGIS. You build the project in QGIS, package it with the QFieldSync plugin, collect and edit in the field with QField on a phone or tablet, and synchronize the changes back into your QGIS data.
What do the QFieldSync packaging actions mean?
Per layer: Copy sends a reference copy whose field edits do not come home; Offline editing sends the layer with a change log so field edits merge back into the master data; Remove drops the layer from the field package entirely. Collection layers need Offline editing; reference layers take Copy; office-only layers should be removed.
Can two people edit the same QField project in the field?
Yes, and this is what offline editing is designed for. Each device logs its changes, and synchronization applies the logs to the master data, so work on different features merges cleanly. Divide the site between collectors so two people rarely edit the same feature, which is where true conflicts can still occur.
Do I need QFieldCloud to use QField?
No. The cable route works fully offline: QFieldSync writes the package to a folder, you copy it to and from the device by USB, and QFieldSync synchronizes the returned package. QFieldCloud adds hosted syncing and team project management for crews that want it.
Where do I design the data entry forms for QField?
In QGIS, in each layer's Attributes Form settings. QField renders the form you design there, so set drop-downs for known vocabularies, defaults for routine values, and hide fields the field should not edit. Form design is the main data quality lever in the whole system.
Photo credits: Mikael Blomkvist (Pexels); Pew Nguyen (Pexels). Photos are served from this site; follow the credit to the library page for the original.