Home / GIS and Open Map Data for Beginners

Shapefile vs Geodatabase: The Limits That Decide Which Container Your Data Deserves

Man in an office setting focused on his work at a computer screen displaying graphs

Photo: Ron Lach / Pexels

Every GIS dataset lives in a container, and the two containers that dominate the Esri centric world could hardly differ more in age or ambition. The shapefile is a multi file format from the early 1990s that became the lingua franca of geographic data exchange. The file geodatabase is Esri's modern single folder container, built to remove the shapefile's limits one by one. This guide compares them on the numbers that actually bite, then gives the decision rule. The shapefile itself is introduced in what is a shapefile; its open format rival is compared in geojson vs shapefile.

Interactive tool

Container Rules: Which Limits Bite You

Check off each step as you finish it. Your progress stays on this page.

0 of 6 complete

0% done

The Shapefile's Hard Limits, Quantified

A shapefile is not one file but a set of files sharing a name: the mandatory .shp (geometry), .shx (index), and .dbf (attributes), plus the .prj that records the coordinate system and several optional companions. Its limits are fossils of its era. Each component file caps at 2 GB, which ends large datasets outright. Field names truncate at 10 characters, so "population_2020" and "population_2024" collide into mangled duplicates on export. The .dbf table cannot store null values, so an empty field becomes a zero or a blank that lies about missing data, and it cannot store a date and a time together. One shapefile holds one geometry type (points, lines, or polygons, never mixed), one feature class per set, no topology rules, no raster, and no behavior beyond storage. Every one of these limits has bitten a real project; the format survives because everything on earth can read it.

The File Geodatabase's Answers

A file geodatabase is a folder (named with a .gdb suffix) holding many feature classes, tables, and rasters as one managed dataset. Its numbers answer the shapefile's list directly: datasets can reach 1 TB each by default, field names run to 64 characters, true nulls are stored honestly, dates carry times, and a single container holds every geometry type plus topologies, domains, subtypes, relationship classes, and versioned workflows. Multiple people can read simultaneously and editing is managed rather than chaotic. It is, in short, a small database wearing a folder's clothes, and inside the ArcGIS ecosystem it is the default working format for good reason. The catch is in the name: it is Esri's container. ArcGIS reads and writes it natively; QGIS reads it well through open drivers and writes it with more friction; web pipelines and non Esri tools often prefer open formats entirely, which is where geojson and its heavier sibling GeoPackage enter the conversation.

Head to Head on the Criteria That Bite

Size: 2 GB per shapefile component versus 1 TB per geodatabase dataset; no contest for big data. Field names: 10 characters versus 64; the shapefile's truncation silently renames your schema on every export. Missing data: shapefiles fake it with zeros and blanks, geodatabases store nulls; for any dataset where "unknown" differs from "zero", this alone decides. Integrity: geodatabase domains and topology rules reject bad edits at the door; a shapefile accepts anything, including self intersecting polygons and duplicate fields. Portability: the shapefile wins outright, readable by every GIS, library, and web tool of the last thirty years, while the geodatabase is an Esri first format. Longevity: a shapefile's simplicity makes it nearly immortal as an archive of a single layer; a geodatabase archives a whole project, relationships included, but ties the archive to one vendor's tooling. Neither column is a shutout, which is why both formats persist.

Hands holding documents analyzing data on a laptop in a collaborative office setting
Hands holding documents analyzing data on a laptop in a collaborative office setting

The Failure Stories That Teach the Rule

Shapefiles fail in characteristic ways. The missing companion: someone emails the .shp alone, and the recipient gets geometry with no attributes and no projection, a map shaped hole. The 2 GB wall mid project, forcing a panicked tiling of a dataset that wanted to be one layer. The truncated schema discovered after a merge, when two years of data turn out to share a mangled field name. Geodatabases fail differently: the vendor lock, when a collaborator outside the Esri world cannot open the container cleanly, and the folder fragility of a format that looks like a folder, inviting someone to tidy files out of it and corrupt the whole. The checklist above compresses these stories into pre flight questions; ask them before the dataset grows teeth.

The Decision Rule

Work in a geodatabase, exchange in open formats, archive with both eyes open. Inside an ArcGIS project, the file geodatabase should be the working home: size, nulls, integrity, and multi layer organization all favor it, and there is no prize for suffering 10 character field names voluntarily. When data leaves the project, export the layer the recipient's tools want: a shapefile when the destination is unknown or legacy (zipping all its component files, always), GeoJSON or GeoPackage for open and web workflows. When data is received as a shapefile, import it into your geodatabase before working, and keep the original zip untouched as the record of what arrived. The shapefile is the envelope, the geodatabase is the filing cabinet, and confusing the envelope for the cabinet is the only real mistake available here. For the foundations under both, what is gis data explains what a container is actually containing.

The Third Contestant Nobody Puts in the Title: GeoPackage

Honest comparisons should admit that the modern open world has largely moved to a third container. GeoPackage is an OGC standard built on a single SQLite file: one file, no 2 GB anxiety for ordinary datasets, field names up to sensible lengths, nulls stored properly, multiple layers per file, and native support in QGIS, GDAL, and most modern pipelines. Against the shapefile it wins on nearly every technical axis while matching its one file portability; against the file geodatabase it wins on openness and loses on Esri native features like topology rules and relationship classes. The working rule extends naturally: geodatabase inside ArcGIS projects, GeoPackage inside open workflows, shapefile when the recipient is unknown, old, or officially requires it, which government portals still do often enough that the format's obituary keeps being postponed. A dataset's container should be chosen by where the data will be opened next, not by where it was born, and conversions between all three are lossless enough, except into shapefile with its truncations, that the choice is a workflow decision rather than a life sentence.

Reading a Stranger's Data: The Intake Inspection

The comparison becomes practical the moment data arrives from someone else, because the container tells you what to inspect. A shapefile intake means checking the entourage first: are .shp, .shx, and .dbf all present, is there a .prj or is the coordinate system a rumor, and do the field names show truncation scars (a field called POPULATIO1 is the sound of a longer name dying)? Open it, count features, and look for the zero that means null. A geodatabase intake means checking the version and the extras: which feature datasets and relationship classes came along, whether domains and subtypes survived the trip, and whether your software version reads the container's version at all. In both cases the deliverable of intake is a one paragraph note, source, date, container, coordinate system, known wounds, filed with the data. Most GIS horror stories are not analysis errors; they are intake errors discovered months later, and the ten minute inspection is the cheapest insurance in the entire discipline. The container debate ends, in practice, at your own door: work in the strong container, and inspect like a skeptic whatever arrives in either.

Related Guides

Readers working through this topic usually need its closest companions too. These GIS and open map data guides cover the neighboring ground:

Frequently Asked Questions

Why is the shapefile still used if it has so many limits?

Because everything reads it. Thirty years of tools, agencies, and archives speak shapefile, so it remains the safest exchange format ever made. Its limits (2 GB files, 10 character field names, no nulls) are real but survivable for single layers in transit, which is the job it is actually for.

What is the maximum size of a shapefile vs a geodatabase?

A shapefile's component files cap at 2 GB each, which bounds the whole layer. A file geodatabase dataset can reach 1 TB by default, and the geodatabase as a whole can hold many such datasets. For anything large or growing, the shapefile ceiling decides the question by itself.

Can QGIS open a file geodatabase?

Yes, for reading, through the open file geodatabase driver, and modern QGIS handles common geodatabase layers well. Writing and advanced geodatabase features (topologies, domains, relationship classes) are ArcGIS territory. If your workflow is QGIS first, GeoPackage is usually the better modern container.

Why did my field names change when I exported to shapefile?

The shapefile's .dbf table limits field names to 10 characters, so longer names are truncated on export, and near identical long names can collide into numbered variants. Keep a schema map when you export, or keep the master data in a geodatabase where 64 character names survive.

Which should I archive my project in?

Archive the working project in its file geodatabase to preserve layers, relationships, and integrity rules, and archive exchange copies of key layers as zipped shapefiles or GeoPackages for tool independence. An archive only one vendor's software can open is a risk; an archive with no structure preserved is a loss.

Photo credits: Ron Lach (Pexels); Yan Krukau (Pexels). Photos are served from this site; follow the credit to the library page for the original.