Somewhere in your project there is a layer of districts, wells, or parcels, and somewhere else there is a spreadsheet that knows things about them: populations, readings, owners, results. The join is the handshake between the two, and QGIS gives you two handshakes that look alike and behave very differently. One, the Processing algorithm Join Attributes by Field Value, manufactures a brand new layer with the table's columns copied in permanently; our field value join guide teaches it. The other, the subject of this guide, is the live join on the Joins tab of Layer Properties: no new layer, no copied data, just your layer wearing the table's fields for as long as the project says so. Each is correct in its season. This guide runs the live join step by step, explains the options that decide whether it behaves, and finishes with the persistence question that bites everyone exactly once.
Home / GIS and Open Map Data for Beginners
QGIS Join by Attribute: The Live Joins Tab, From Shared Field to Saved Project

Photo: Artem Podrez / Pexels
Join Without Duplicating: The Live Join Checklist
Check off each step as you finish it. Your progress stays on this page.
0 of 7 complete
0% done
Before the Dialog: The Shared Field Is the Whole Game
A live join matches rows by equality in one field on each side: the target field in your layer and the join field in the table. Everything about the join's success is decided by those two columns before the dialog opens. Inspect them like a skeptic. The values must be truly equal, which is a stricter test than looking equal: the district code 07 in one file and 7 in the other will not match if one side stores text and the other stores numbers, trailing spaces hide in imported CSVs like burrs, and codes that look numeric but contain letters will sort and match as text or not at all. Open both attribute tables, sort by the candidate field, and eyeball the alignment. Check for duplicates in the join table: a live join takes the first matching row it finds, so a join table with two rows per district will silently choose one of them and never tell you. And decide which rows deserve to survive unmatched: features whose code finds no partner will carry NULL in every joined field, which is honest, visible, and often exactly the diagnostic you needed about your data. Clean fields join cleanly. The dialog is the easy part.
The Joins Tab, Field by Field
Open the layer's Properties and go to the Joins tab, then add a join with the plus button. The dialog asks for four decisions. Join layer: the table or layer supplying the facts, which must already be loaded in the project; a plain CSV added as a delimited text layer works perfectly as a join source. Join field: the shared column on the table's side. Target field: the shared column on your layer's side. Then the options that shape daily life with the join. The custom field prefix renames the incoming columns so you can tell at a glance which fields are yours and which are borrowed; set a short prefix you will recognize months later, because the attribute table will not explain itself. The field selection below lets you import only the columns you need instead of the table's whole biography, and a lean join is a fast, readable join. Two performance options live here too: caching the join in memory, and creating an attribute index on the join field, both worth enabling for large tables, since a live join re-evaluates as you pan, filter, and label. Apply, open your attribute table, and the borrowed fields stand at the end of the row, live.

Living With a Live Join
The joys and the traps of the live join both flow from its liveness. Edit the source table, correct a population, add this month's readings, and your layer knows immediately: symbology reclassifies, labels update, the attribute table shows the new values, because nothing was ever copied. This is the join for dashboards, for monthly data that arrives as a fresh CSV, for the project you are still exploring, where baking a copy every iteration would litter the folder with fossils. The traps are the mirror image. Joined fields are read-only through your layer; you cannot edit the table's values from the map side. Some operations treat joined fields as second-class citizens, and exports and processing runs deserve a suspicious check the first time: confirm the output really carries the borrowed columns before you build on it. And the join's definition lives in the project file. Send a colleague the layer alone and it arrives naked, its borrowed fields gone, its styled symbology suddenly classifying nothing. None of this argues against the live join. It argues for knowing which join you are holding, which brings us to the question that decides most real work.
Live Join or Baked Layer: Choosing on Purpose
Choose the live join when the table is still changing, when the same table feeds several layers, when you are exploring and expect to change your mind, or when the joined view is a working state rather than a deliverable. Choose the baked layer, the Processing algorithm's new permanent layer, when the result must travel: to a colleague, to a web map, into an archive, or into any pipeline whose next step should not depend on your project file's memory. The mature pattern uses both in sequence. Explore with the live join, argue with the data, fix the table, and when the analysis settles, run the field value join once to mint the deliverable layer, with the live join removed from the working project to prevent the two from drifting apart in your head. Our spatial join guide covers the third sibling, joining by location rather than by shared field, for the day your two datasets share geography but no column. And when the borrowed fields inspire calculations of their own, the expression builder is where joined data goes to be computed with, since expressions read joined fields like native ones.
The Persistence Question: Saving What You Built
Because the live join lives in the project, persistence has three distinct meanings, and confusing them is the classic accident. Save the project and the join survives exactly as defined, ready to reopen, as long as the join table's file stays where the project expects it; move the CSV and the join breaks on open, with the layer arriving stripped. Export the layer with Save As while the join is active and the borrowed fields are written into the new file permanently: this is the deliberate way to bake a live join you have decided to keep, and it produces the same result as the Processing route through a different door. Save the layer's style and you save how it looks, not the join that feeds it. The working rules write themselves. Keep join tables in a stable project folder beside the project file, never in a downloads folder with ambitions. When a project becomes a deliverable, export the joined layers and note in the filename or the metadata that the fields were joined, from which table, on which field, on which date. Future you, reopening this in a year, is a stranger who deserves documentation. Present you is the only one who can write it.
Several Tables, One Layer: Stacking Joins and Reading the Result
Real layers rarely borrow from one table. The districts layer wants census populations from one file, health outcomes from a second, and this quarter's program results from a third, and the Joins tab happily stacks them: add a join per table, each with its own field pairing and prefix, and the attribute table grows three borrowed wings. Stacking raises the craft questions. Prefixes stop being etiquette and become survival, because three tables will all contain a field called Name or Total, and the layer that cannot tell its borrowed columns apart cannot be styled, filtered, or explained. Cardinality deserves a second, colder look at scale: each join assumes its table holds at most one row per key, and a duplicated key in any one of the three will silently misattach facts in that wing while the others stay true, a corruption pattern that spot-checking a single join will miss. Check each wing separately, on records you know. And performance becomes a design constraint: every live join re-evaluates as the project works, so three fat tables joined live to a heavy layer will tax every pan and render until you cache, index, or, at the point the analysis settles, bake the whole assembly into one honest layer with the algorithm and retire the stack. The stack is a working state with excellent properties. Treat it as scaffolding, admire it while it stands, and know which day you intend to replace it with the building.
What the Join Does to Everything Downstream
A live join reaches further than the attribute table, and knowing its blast radius prevents the classic surprises. Styling and labels see the borrowed fields as full citizens: categorize districts by a joined health indicator, label parcels with a joined owner name, and the map wears the join's data as if it were its own, which it temporarily is. Exports are where the arrangement shows its seams: export the layer to a new file and the joined fields typically come along as real columns, a quiet bake performed by the export; share the project file instead, and the recipient needs the joined table too, in the same relative place, or the join fails open into empty columns. Print layouts and reports read the joined table live, so a layout exported after the lookup table changed will print different numbers from the same map, one more reason settled work gets baked before it gets published. Field order and naming in the attribute table follow the join's arrival, with borrowed wings appended after native fields under their prefixes, and a moment spent setting friendly aliases in the layer's fields view repays itself every time a colleague reads the table. None of this argues against the live join. It argues for knowing which of your products are standing on it, so that when the table updates, the style refreshes, or the project travels, you can predict what moves and what must not.
Related Guides
Readers working through this topic usually need its closest companions too. These GIS and open data guides cover the neighboring ground:
- QGIS Join Attributes by Field Value: Attach a Table to Your Layer by a Shared Key: The baked sibling: the Processing algorithm that mints a new permanent layer with the table copied in.
- QGIS Spatial Join: Join Attributes by Location, Explained With Its Predicates: Joining by geography instead of by shared field, for datasets that share ground but no column.
- The QGIS Attribute Table: Rows Are Places, Columns Are Facts: Where joined fields land and how to read, sort, and interrogate them once they arrive.
- QGIS Expression Builder: The One Dialog Behind Selection, Fields, and Styles: Expressions read joined fields like native ones; this is where borrowed data goes to be computed with.
Frequently Asked Questions
What is the difference between the Joins tab and Join Attributes by Field Value?
The Joins tab creates a live join: your layer displays the table's fields without copying them, updates when the table changes, and is stored in the project. The Processing algorithm creates a new permanent layer with the fields copied in. Use the live join for changing data and exploration, the algorithm for deliverables.
Why did my join produce NULL values everywhere?
The shared fields do not truly match: different types, text against numbers, stray spaces, or codes that differ between the files. Sort both columns side by side and compare them exactly. Type and formatting mismatches are the cause in nearly every failed join.
Can I edit joined fields from my layer?
No. Joined fields are read-only through the layer. Edit the source table instead; the live join reflects the change immediately, which is precisely its advantage.
How do I make a live join permanent?
Either run the Join Attributes by Field Value algorithm to mint a new layer, or export the layer with Save As while the join is active. Both write the borrowed fields into a real file. Saving the project alone keeps the join only inside that project.
What happens if the join table has duplicate keys?
The live join takes the first matching row it finds for each feature and does not warn you. Deduplicate the join table first, or the wrong facts will attach silently.
Photo credits: Artem Podrez (Pexels); Tima Miroshnichenko (Pexels). Photos are served from this site; follow the credit to the library page for the original.