Short answer

Field mapping data management is the discipline of getting observations out of the field and into a trustworthy master dataset without losing precision, provenance, or meaning. The work that matters happens before anyone walks a transect: defining a typed schema with controlled vocabularies, deciding the positional accuracy you actually need, and planning how offline edits will sync and how conflicts will be resolved. Do that well and the office work is a merge; do it badly and you spend the post-field weeks reverse-engineering what "ls" in a free-text field meant.

Design the schema before you go to the field

The cardinal rule: never collect geological observations into free-text fields you intend to clean up later. Define the data model up front, with typed columns and controlled vocabularies (domains/value lists) so the device only offers valid choices.

A minimal geological field schema usually has:

  • Stations (points): station_id, date, observer, lithology (coded list), notes, gnss_accuracy_m, photo_id.
  • Structural measurements (points): station_id, feature_type (bedding, foliation, joint, fault), dip_direction (0–360), dip (0–90), convention (dip-azimuth vs strike/dip-RHR). Recording the convention explicitly prevents the most common structural data disaster.
  • Contacts and faults (lines): contact_type, confidence (certain / approximate / inferred / concealed), source.
  • Samples (points): sample_id, sample_type, target, lab_ref.

Store this as a GeoPackage (a single SQLite file, OGC standard) or an Esri geodatabase. GeoPackage supports multiple layers, attribute constraints and a defined CRS in one portable file, which makes it the natural offline container. Add a UNIQUE constraint on station_id and CHECK constraints on numeric ranges so bad values are rejected at entry:

CREATE TABLE structure (
  fid INTEGER PRIMARY KEY,
  station_id TEXT NOT NULL,
  feature_type TEXT CHECK (feature_type IN ('bedding','foliation','joint','fault')),
  dip_direction INTEGER CHECK (dip_direction BETWEEN 0 AND 360),
  dip INTEGER CHECK (dip BETWEEN 0 AND 90)
);

Positional accuracy: match the fix to the feature

Not every observation needs the same precision, and pretending otherwise wastes time and battery.

  • Phone / tablet GNSS: roughly 3–10 m horizontal under open sky, worse under canopy or against cliffs. Adequate for context stations and photo points.
  • Recreational handheld GPS: 2–5 m typical.
  • RTK / PPK GNSS (external receiver, base or NTRIP correction): centimetre to sub-metre. Use it for mapped contacts, trench and pit locations, sample sites that feed resource estimates, and any feature whose position will be measured against later.

Always log the accuracy estimate with every fix. A point with no recorded accuracy is unusable for any quantitative comparison because you cannot tell whether a 5 m discrepancy is a real geological detail or GNSS noise. Multipath near rock faces and signal loss under tree cover are the usual culprits when fixes degrade; in those settings prefer averaging or PPK post-processing.

Also pin down the datum. Field receivers report in WGS84 (EPSG:4326) by default; your project may be on a national datum. Transform deliberately on import rather than letting the device guess — a datum mismatch can introduce a consistent offset of several metres to over a hundred metres depending on the area.

Offline collection and sync

Most mapping happens with no connectivity, so the architecture is offline-first.

  • QField (with Mergin Maps for sync) packages a QGIS project — layers, styles, forms, value lists — into a single offline bundle. Mappers edit locally; Mergin syncs deltas back and pulls others' edits down.
  • ArcGIS Field Maps does the equivalent in the Esri stack with offline map areas and feature service sync.

Configure the capture forms so they enforce the schema: drop-downs for coded lists, default values, required fields, and constrained ranges. The form is your last line of defence against dirty data.

Plan conflict resolution before fieldwork, not after. When two mappers edit the same area or the same feature offline, sync must decide who wins. The safe pattern is feature-level partitioning (each mapper owns a sheet or block) plus a documented rule (last-writer-wins, or manual review for overlaps). Set the project CRS in the offline package so every fix lands in the same frame.

Worked workflow: field to master dataset

  1. Author the QGIS project with the typed schema, forms and value lists; set the project CRS (e.g. the correct UTM zone).
  2. Package it for QField/Mergin and distribute to devices.
  3. Map. Capture stations, structures, contacts; attach photos by photo_id; let the device record gnss_accuracy_m.
  4. Sync daily where possible so you catch problems while still on site.
  5. Validate on return (next section).
  6. Merge clean deltas into the master GeoPackage or PostGIS database; tag each batch with date and observer.

To pull a day's edits into PostGIS:

ogr2ogr -f PostgreSQL "PG:dbname=mapping" field_day.gpkg \
  -t_srs EPSG:32633 -nln field.stations -append

QA before the merge

Run a fixed checklist; do not merge until it passes.

  • Geometry validity: QGIS Fix geometries / ST_MakeValid; check for null geometries.
  • Attribute ranges: dip 0–90, dip-direction 0–360, no empty coded fields. A quick filter dip > 90 OR dip_direction > 360 should return nothing.
  • Convention consistency: confirm every structural reading uses the same strike/dip convention; mixed conventions silently rotate your stereonet.
  • Accuracy: flag fixes worse than the project threshold (e.g. gnss_accuracy_m > 5 for contacts).
  • Uniqueness: no duplicate station_id; sample IDs match the lab manifest.
  • CRS: confirm everything is in the project CRS, not raw WGS84.
  • Photos: every photo_id resolves to a file.

Common pitfalls and why they happen

  • Free-text where a code belongs. Inconsistent spellings ("granite", "Granite", "gran.") happen because the form allowed typing instead of selecting. Use value lists.
  • Lost accuracy metadata. If the app isn't configured to store the accuracy field, you cannot later distinguish a survey-grade point from a phone guess. Configure it before day one.
  • Datum drift. Importing WGS84 field data into a national-grid project without transforming produces a systematic shift that looks like real geology but isn't.
  • Sync conflicts overwriting work. Two mappers, one feature, last-writer-wins — and a morning's mapping vanishes. Partition the area and agree the rule beforehand.
  • Convention ambiguity. Strike/dip vs dip/dip-direction recorded inconsistently makes structural analysis meaningless. Force the convention as a field.
  • Editing the master in the field. Always work on a copy and merge deliberately, so a device failure never corrupts the canonical dataset.

Bathyl perspective

We design field data as something the office can trust on arrival, not clean up after. A schema with enforced domains, logged accuracy and a planned sync model turns weeks of post-field reconciliation into a same-day merge — and keeps the link between an observation and the person, instrument and moment that produced it.

Related reading

Sources