← All articles

By ·

12 Automated QA Checks for Road Centerlines and Address Points Before NG911 Submission

NG911 GIS data validation in PostGIS: 12 automated QA checks for address ranges, parity, dangles, duplicate address points and boundary gaps, with SQL.

Aerial view of a residential street grid with houses on both sides of each road
Photo: Tom Rumble on Unsplash

NG911 GIS data validation is a set of automated checks that confirms road centerlines, address points and boundaries can route a 911 call: valid geometry in a known CRS, required NENA attributes present, address ranges with correct parity and no overlaps, a connected network, address points that agree with centerlines, and boundaries without gaps or overlaps.

This article gives 12 checks I run before an NG911 submission. For each one: what it catches, why NG911 routing cares, and a query you can paste into PostGIS, with GeoPandas where Python is the more natural tool.

What should NG911 GIS data validation check?

NG9-1-1 replaces the tabular routing of E9-1-1 with GIS. The Emergency Call Routing Function (ECRF) asks "which PSAP polygon contains this location?", and the Location Validation Function (LVF) asks "does this civic address exist, and where?" Both are answered from your road centerlines (RoadCenterLine), site/structure address points (SiteStructureAddressPoint) and boundary polygons. Every check below protects one of those two questions.

The list is built from two sources. The NENA Standard for NG9-1-1 GIS Data Model (NENA-STA-006.2a-2022) defines the layers, field names and domains. NSGIC's Recommended Validations for NG9-1-1 GIS Data, published May 2026, lists the validations state programs and vendors use. If you are earlier in the process, start with my NG911 GIS data readiness checklist, which covers which layers you need and how to score where you stand.

#CheckLayerTypical severity
1Invalid, empty or multipart geometryAllBlocks submission
2CRS and unitsAllBlocks submission
3Missing mandatory attributes, bad domains, duplicate IDsAllBlocks submission
4From/To inversionsCenterlinesError
5Parity errorsCenterlinesError
6Address range overlapsCenterlinesError (routing ambiguity)
7Dangling nodes, undershoots, overshootsCenterlinesError or review
8Duplicate address pointsAddress pointsError
9Points outside the authoritative boundaryAddress pointsError
10Points far from, or on the wrong side of, their centerlineAddress pointsReview
11Street name mismatch between points and centerlinesBothError
12Boundary gaps and overlapsPolygonsBlocks submission

Severity is my default; your state or NG9-1-1 provider may grade them differently.

Six schematic panels of NG911 data errors: overlapping address ranges on the same street, an even address on the odd side, a road that ends short of an intersection, an address point 620 m from its street, a gap and an overlap between two emergency service boundaries, and a duplicated address point

Six of the errors the checks below catch, numbered to match the checks.

How to set up the data in PostGIS

The queries assume five tables loaded into PostgreSQL with PostGIS: rcl (centerlines), ssap (address points), psap (PSAP polygons), prov (provisioning boundary) and muni (municipal polygons with a name column). Geometry is in a column called geom, in a projected CRS measured in metres, such as a UTM zone. If your data is in US survey feet, multiply the distance thresholds by 3.28.

Field names follow NENA-STA-006.2a: FromAddr_L, ToAddr_L, FromAddr_R, ToAddr_R, Parity_L, Parity_R, St_Name, Add_Number, IncMuni_L, Inc_Muni and so on. When you load with ogr2ogr, the PostgreSQL driver launders field names to lower case by default, so FromAddr_L becomes fromaddr_l. The SQL uses those lower-case names.

ogr2ogr -f PostgreSQL PG:"dbname=ng911" rcl.shp -nln rcl -lco GEOMETRY_NAME=geom -nlt PROMOTE_TO_MULTI
ogr2ogr -f PostgreSQL PG:"dbname=ng911" ssap.shp -nln ssap -lco GEOMETRY_NAME=geom

Two helper views build a single comparable street name from the parsed NENA parts, and spatial indexes keep the self-joins fast:

CREATE EXTENSION IF NOT EXISTS pg_trgm;

CREATE OR REPLACE VIEW rcl_k AS
SELECT r.*,
       upper(concat_ws(' ', st_premod, st_predir, st_pretyp, st_presep,
                       st_name, st_postyp, st_posdir, st_posmod)) AS street_key
FROM rcl r;

CREATE OR REPLACE VIEW ssap_k AS
SELECT s.*,
       upper(concat_ws(' ', st_premod, st_predir, st_pretyp, st_presep,
                       st_name, st_postyp, st_posdir, st_posmod)) AS street_key
FROM ssap s;

CREATE INDEX IF NOT EXISTS rcl_geom_idx ON rcl USING gist (geom);
CREATE INDEX IF NOT EXISTS ssap_geom_idx ON ssap USING gist (geom);
CREATE INDEX IF NOT EXISTS psap_geom_idx ON psap USING gist (geom);

Run the checks in order. Checks 1 to 3 make the later queries trustworthy: a range query on a null FromAddr_L or a distance query in degrees produces noise.

1. Which features have invalid, empty or multipart geometry?

What it catches: self-intersecting polygons, bow-tie rings, empty or null shapes, self-crossing lines and multipart features.

Why NG911 cares: the ECRF answers point-in-polygon queries. An invalid PSAP polygon can make that test return the wrong answer or fail. NSGIC lists empty or invalid geometry as an NG9-1-1 priority for every layer, and notes that multipart features may not be allowed, depending on the provider.

SELECT 'rcl' AS layer, nguid,
       coalesce(ST_IsValidReason(geom), 'null geometry') AS issue
FROM rcl
WHERE geom IS NULL OR ST_IsEmpty(geom) OR NOT ST_IsValid(geom)
   OR NOT ST_IsSimple(geom) OR ST_NumGeometries(geom) > 1
UNION ALL
SELECT 'psap', nguid, coalesce(ST_IsValidReason(geom), 'null geometry')
FROM psap
WHERE geom IS NULL OR ST_IsEmpty(geom) OR NOT ST_IsValid(geom)
   OR ST_NumGeometries(geom) > 1;

ST_IsValid returns true for a line that crosses itself, which is why centerlines also need ST_IsSimple. Once no centerline has more than one part, convert the column to single-part lines, because checks 7 and 10 use functions that expect a LineString (replace 26911 with your SRID):

ALTER TABLE rcl ALTER COLUMN geom TYPE geometry(LineString, 26911)
  USING ST_GeometryN(geom, 1);

The same validity test in GeoPandas:

import geopandas as gpd

rcl = gpd.read_file("ng911.gpkg", layer="rcl")
bad = rcl[rcl.geometry.isna() | rcl.is_empty | ~rcl.is_valid | ~rcl.is_simple]
print(len(bad), "centerlines with geometry problems")

This is the class of problem I wrote GeoLint for. It is my open-source linter for vector data: geolint validate rcl.gpkg --json reports invalid geometry, self-intersecting lines, dangles, duplicate vertices and polygon coverage gaps, and geolint fix repairs the purely geometric ones. It does not know NENA attribute rules, so it covers checks 1, 2, 7 and 12 and leaves the address logic to the SQL here.

2. Is every layer in a known CRS with the right units?

What it catches: layers with no SRID (SRID 0), layers in different coordinate systems, data in degrees being measured as if it were metres, and feet mistaken for metres.

Why NG911 cares: NENA-STA-006.2a §3.3 lets you maintain data in any datum and projection, but it must be transformed to WGS84 (EPSG:4326 for 2D, EPSG:4979 for 3D) before loading into the ECRF. A wrong source CRS shifts every feature, and the PSAP boundary shifts with it.

SELECT g.f_table_name, g.srid, g.type, s.proj4text
FROM geometry_columns g
LEFT JOIN spatial_ref_sys s ON s.srid = g.srid
WHERE g.f_table_name IN ('rcl', 'ssap', 'psap', 'prov', 'muni');

-- Sanity check the units: median segment length and the layer extent in lon/lat
SELECT percentile_cont(0.5) WITHIN GROUP (ORDER BY ST_Length(geom)) AS median_len,
       ST_Extent(ST_Transform(geom, 4326)) AS extent_wgs84
FROM rcl;

Look for +units=m or +units=us-ft in proj4text. A median segment length below 0.01 means the data is in degrees. The WGS84 extent should sit on your county; if it lands in the ocean or another state, the declared SRID is wrong. In Python, gdf.crs and gdf.crs.axis_info[0].unit_name give the same answers, and geolint info rcl.shp.zip --infer-crs suggests a CRS when a shapefile arrives without a .prj.

3. Are mandatory attributes, domains and IDs complete?

What it catches: null or blank required fields, values outside NENA domains and duplicated NGUIDs.

Why NG911 cares: NENA-STA-006.2a says an NGUID is required for every GIS data element, and marks fields such as DiscrpAgID, DateUpdate, the four range fields, both parity fields, St_Name and the left/right country, state, county and municipality fields as required on centerlines. The provider's ingest rejects records missing them, and error reports reference features by NGUID.

SELECT
  count(*) FILTER (WHERE nullif(trim(nguid), '') IS NULL)      AS no_nguid,
  count(*) FILTER (WHERE nullif(trim(discrpagid), '') IS NULL) AS no_discrpagid,
  count(*) FILTER (WHERE dateupdate IS NULL)                   AS no_dateupdate,
  count(*) FILTER (WHERE fromaddr_l IS NULL OR toaddr_l IS NULL
                      OR fromaddr_r IS NULL OR toaddr_r IS NULL) AS no_ranges,
  count(*) FILTER (WHERE parity_l IS NULL OR parity_l NOT IN ('O','E','B','Z')
                      OR parity_r IS NULL OR parity_r NOT IN ('O','E','B','Z')) AS bad_parity_code,
  count(*) FILTER (WHERE nullif(trim(st_name), '') IS NULL)    AS no_st_name,
  count(*) FILTER (WHERE incmuni_l IS NULL OR incmuni_r IS NULL
                      OR county_l IS NULL OR county_r IS NULL) AS no_place_names
FROM rcl;

SELECT nguid, count(*) FROM rcl GROUP BY nguid HAVING count(*) > 1;

nullif(trim(x), '') treats blank strings as missing. NSGIC recommends storing empty optional attributes as true nulls, and blanks are the most common way a "populated" field turns out to be empty. Run the same pattern on ssap with its required fields (Country, State, County, Inc_Muni, plus Add_Number and St_Name for thoroughfare addresses).

4. Which centerlines have From and To addresses reversed?

What it catches: segments where the From address is higher than the To address on one or both sides.

Why NG911 cares: NENA defines the From address relative to the segment's FROM node, the start of the line. Geocoding interpolates along the line from that node, so a reversed range puts 100 Main St at the far end of the block. NSGIC recommends digitizing in the direction of increasing addresses.

SELECT nguid, fromaddr_l, toaddr_l, fromaddr_r, toaddr_r,
       CASE WHEN fromaddr_l > toaddr_l AND fromaddr_r > toaddr_r
            THEN 'both sides descending: line probably digitized backwards'
            ELSE 'one side descending: probable data entry swap'
       END AS issue
FROM rcl
WHERE fromaddr_l > toaddr_l OR fromaddr_r > toaddr_r;

The two cases need different fixes. If both sides descend, reverse the geometry with ST_Reverse, but remember that reversing a line also swaps its left and right sides: the left range, parity and place names must move to the right fields, and From and To swap. If one side descends, it is usually a typo in that side's range.

5. Which address ranges have parity errors?

What it catches: a side coded odd whose range starts or ends on an even number (or the reverse), Z coded on a non-zero range, a real range coded as zero, and both sides of a segment with the same odd or even parity.

Why NG911 cares: NENA's domain for Parity_L and Parity_R is O (odd), E (even), B (both) and Z (address range 0-0). The LVF and geocoders use parity to choose a side of the street. Wrong parity puts an address on the wrong side, and near a boundary that is a different PSAP or fire district.

WITH sides AS (
  SELECT nguid, 'L' AS side, parity_l AS parity,
         fromaddr_l::int AS a, toaddr_l::int AS b
  FROM rcl
  UNION ALL
  SELECT nguid, 'R', parity_r, fromaddr_r::int, toaddr_r::int
  FROM rcl
)
SELECT nguid, side, parity, a, b
FROM sides
WHERE (parity = 'O' AND (a % 2 = 0 OR b % 2 = 0))
   OR (parity = 'E' AND (a % 2 <> 0 OR b % 2 <> 0))
   OR (parity = 'Z' AND (a <> 0 OR b <> 0))
   OR (parity IN ('O', 'E', 'B') AND a = 0 AND b = 0);

-- Both sides odd or both even: usually a coding error
SELECT nguid, parity_l, parity_r
FROM rcl
WHERE parity_l = parity_r AND parity_l IN ('O', 'E');

The ::int cast matters. Shapefile number fields sometimes load as double precision, and PostgreSQL has no % operator for that type.

6. Where do address ranges overlap on the same street?

What it catches: two segments with the same full street name, in the same county and municipality, whose ranges claim the same address numbers on compatible parity.

Why NG911 cares: an overlapping range means one civic address resolves to two places. NSGIC states that overlapping ranges on centerlines with the same street name in the same jurisdiction cannot exist. Routing to the wrong segment can mean routing to the wrong PSAP or the wrong first-due station.

WITH sides AS (
  SELECT nguid, street_key, county_l AS county, incmuni_l AS muni, parity_l AS parity,
         least(fromaddr_l, toaddr_l)::int AS lo, greatest(fromaddr_l, toaddr_l)::int AS hi
  FROM rcl_k WHERE parity_l <> 'Z'
  UNION ALL
  SELECT nguid, street_key, county_r, incmuni_r, parity_r,
         least(fromaddr_r, toaddr_r)::int, greatest(fromaddr_r, toaddr_r)::int
  FROM rcl_k WHERE parity_r <> 'Z'
)
SELECT a.street_key, a.muni, a.nguid AS seg_a, a.lo AS a_lo, a.hi AS a_hi,
       b.nguid AS seg_b, b.lo AS b_lo, b.hi AS b_hi
FROM sides a
JOIN sides b
  ON a.street_key = b.street_key
 AND a.county = b.county
 AND a.muni = b.muni
 AND a.nguid < b.nguid
 AND int4range(a.lo, a.hi, '[]') && int4range(b.lo, b.hi, '[]')
 AND (a.parity = 'B' OR b.parity = 'B' OR a.parity = b.parity)
ORDER BY a.street_key, a.lo;

The parity condition stops false alarms: 100-198 even on one side and 101-199 odd on the other share a numeric span but no address. A pair such as 100-198 and 198-298, both even, is a true overlap at 198, the classic off-by-two error at a block break.

7. Where are the dangling nodes, undershoots and overshoots?

What it catches: segment ends that stop just short of the road they should meet (undershoots), segments that run past an intersection without a node (overshoots), and floating segments connected to nothing.

Why NG911 cares: NSGIC lists floating lines and snapping errors among its centerline validations. A broken network also breaks the drive-time and routing tools that dispatch and CAD systems run on the same centerlines.

WITH ends AS (
  SELECT nguid, ST_StartPoint(geom) AS pt FROM rcl
  UNION ALL
  SELECT nguid, ST_EndPoint(geom) FROM rcl
),
dangles AS (
  SELECT e.nguid, e.pt
  FROM ends e
  WHERE NOT EXISTS (
    SELECT 1 FROM rcl r
    WHERE r.nguid <> e.nguid AND ST_Intersects(r.geom, e.pt)
  )
)
SELECT d.nguid AS dangling_segment, n.nguid AS nearest_segment,
       round(ST_Distance(d.pt, n.geom)::numeric, 2) AS gap_m,
       ST_AsText(d.pt) AS location
FROM dangles d
CROSS JOIN LATERAL (
  SELECT r.nguid, r.geom
  FROM rcl r
  WHERE r.nguid <> d.nguid AND ST_DWithin(r.geom, d.pt, 10)
  ORDER BY r.geom <-> d.pt
  LIMIT 1
) n;

-- Overshoots and unnoded crossings
SELECT a.nguid, b.nguid
FROM rcl a
JOIN rcl b ON a.nguid < b.nguid AND ST_Crosses(a.geom, b.geom);

The first query keeps only dangles within 10 m of another segment. A dead end or cul-de-sac is also a dangle, but nothing is near it, so it drops out. The second query also returns overpasses and bridges, where two roads cross without meeting. Those are correct, so review the list rather than auto-snapping it.

8. Which address points are duplicates?

What it catches: two or more points with the same full civic address in the same municipality and no subaddress to tell them apart.

Why NG911 cares: NSGIC says duplicate features with the same attribution across all required and conditional civic address fields are not allowed. The LVF cannot tell which one a caller means, and if the duplicates sit far apart, one of them is in the wrong place.

SELECT add_number, addnum_suf, street_key, inc_muni, unit,
       count(*) AS copies,
       array_agg(nguid) AS ids,
       round(max(ST_Distance(geom, c))::numeric, 1) AS max_spread_m
FROM (
  SELECT s.*, ST_Centroid(ST_Collect(geom) OVER (
           PARTITION BY add_number, addnum_suf, street_key, inc_muni, unit)) AS c
  FROM ssap_k s
) x
GROUP BY add_number, addnum_suf, street_key, inc_muni, unit
HAVING count(*) > 1
ORDER BY max_spread_m DESC;

max_spread_m sorts the results usefully. Copies a few metres apart are usually a double digitization; delete one. Copies hundreds of metres apart mean one address was assigned twice, which is a question for the addressing authority.

9. Which address points fall outside the authoritative boundary?

What it catches: points outside your provisioning boundary, points that are in no PSAP polygon or in two, and points whose Inc_Muni attribute names a different municipality from the polygon they sit in.

Why NG911 cares: NENA-STA-006.2a §4.4 says a GIS data provider must only include data within its provisioning boundary. NSGIC adds that every feature must be inside the required service boundary polygons, or it can cause ambiguous responses to ECRF and LVF queries.

SELECT s.nguid, 'outside provisioning boundary' AS issue
FROM ssap s
WHERE NOT EXISTS (SELECT 1 FROM prov p WHERE ST_Intersects(p.geom, s.geom))
UNION ALL
SELECT s.nguid, 'in ' || (SELECT count(*) FROM psap p WHERE ST_Intersects(p.geom, s.geom)) || ' PSAP polygons'
FROM ssap s
WHERE (SELECT count(*) FROM psap p WHERE ST_Intersects(p.geom, s.geom)) <> 1
UNION ALL
SELECT s.nguid, 'Inc_Muni is ' || coalesce(s.inc_muni, 'null') || ', polygon is ' || coalesce(m.name, 'Unincorporated')
FROM ssap s
LEFT JOIN muni m ON ST_Intersects(m.geom, s.geom)
WHERE s.inc_muni IS DISTINCT FROM coalesce(m.name, 'Unincorporated');

NSGIC recommends the literal value "Unincorporated" for addresses outside any incorporated municipality, which is what the coalesce matches. Repeat the PSAP test for the fire, police and EMS polygons.

10. Which points are far from, or on the wrong side of, their centerline?

What it catches: address points more than 150 m from the centerline segment whose name and range match them, and points on the opposite side of the road from the range that contains their number.

Why NG911 cares: NENA-STA-006.2a says address number, street name and place names on address points should be consistent with the ranges and names on the centerlines. NSGIC lists "SSAP located on the correct side of the road" and "address point misordered along road centerline" as validations. A point on the wrong side usually means the point, the range or the parity is wrong.

WITH m AS (
  SELECT s.nguid AS ssap_id, s.add_number, s.geom AS pt,
         r.nguid AS rcl_id, r.geom AS line,
         CASE WHEN s.add_number BETWEEN least(r.fromaddr_l, r.toaddr_l) AND greatest(r.fromaddr_l, r.toaddr_l)
                   AND r.parity_l IN ('B', CASE WHEN s.add_number::int % 2 = 0 THEN 'E' ELSE 'O' END) THEN 'L'
              WHEN s.add_number BETWEEN least(r.fromaddr_r, r.toaddr_r) AND greatest(r.fromaddr_r, r.toaddr_r)
                   AND r.parity_r IN ('B', CASE WHEN s.add_number::int % 2 = 0 THEN 'E' ELSE 'O' END) THEN 'R'
         END AS range_side
  FROM ssap_k s
  JOIN rcl_k r
    ON r.street_key = s.street_key
   AND s.inc_muni IN (r.incmuni_l, r.incmuni_r)
),
g AS (
  SELECT m.*, ST_Distance(pt, line) AS dist_m,
         ST_LineInterpolatePoint(line, greatest(ST_LineLocatePoint(line, pt) - 0.001, 0)) AS p1,
         ST_LineInterpolatePoint(line, least(ST_LineLocatePoint(line, pt) + 0.001, 1)) AS p2
  FROM m
  WHERE range_side IS NOT NULL
)
SELECT ssap_id, rcl_id, add_number, range_side,
       CASE WHEN (ST_X(p2) - ST_X(p1)) * (ST_Y(pt) - ST_Y(p1))
               - (ST_Y(p2) - ST_Y(p1)) * (ST_X(pt) - ST_X(p1)) > 0
            THEN 'L' ELSE 'R' END AS geometric_side,
       round(dist_m::numeric, 1) AS dist_m
FROM g
WHERE dist_m > 150
   OR range_side <> CASE WHEN (ST_X(p2) - ST_X(p1)) * (ST_Y(pt) - ST_Y(p1))
                            - (ST_Y(p2) - ST_Y(p1)) * (ST_X(pt) - ST_X(p1)) > 0
                         THEN 'L' ELSE 'R' END;

The side test takes two points just before and after the closest point on the line and computes the sign of a cross product: positive means the address point is to the left of the direction of travel. ST_LineLocatePoint needs single-part lines, which is why check 1 ends by converting the column. Points that never appear in m with a range_side have no matching centerline at all; check 11 explains most of those.

The 150 m threshold is a starting point, not a standard. Rural parcels with long driveways legitimately sit far from the road, so set a tighter threshold in town and a looser one outside it, or exempt points whose Placement method is a driveway or parcel centroid.

11. Which address point street names have no matching centerline?

What it catches: street names on address points that do not exist on any centerline in the same municipality, with the closest centerline name as a suggested fix.

Why NG911 cares: the LVF validates a civic address against your data. If points say "MAPLE RIDGE DR" and the centerline says "MAPLERIDGE DR", the address can fail validation or geocode to the wrong place. NSGIC lists SSAP and RCL attribute consistency as an NG9-1-1 priority.

SELECT s.street_key, s.inc_muni, count(*) AS points,
       (SELECT r.street_key
        FROM rcl_k r
        WHERE s.inc_muni IN (r.incmuni_l, r.incmuni_r)
        ORDER BY similarity(r.street_key, s.street_key) DESC
        LIMIT 1) AS closest_centerline_name
FROM ssap_k s
WHERE NOT EXISTS (
  SELECT 1 FROM rcl_k r
  WHERE r.street_key = s.street_key
    AND s.inc_muni IN (r.incmuni_l, r.incmuni_r)
)
GROUP BY s.street_key, s.inc_muni
ORDER BY points DESC;

similarity() comes from the pg_trgm extension created in the setup step. Typical results are spacing ("MAPLE RIDGE" and "MAPLERIDGE"), abbreviations left in the name field ("ST" in St_Name instead of St_PosTyp) and post-type disagreements ("DR" against "DRIVE"). Fix the parsing rule once and rerun, rather than editing hundreds of points by hand.

12. Where do service and provisioning boundaries have gaps or overlaps?

What it catches: slivers where two PSAP polygons overlap, and holes where part of your provisioning area is covered by no PSAP polygon.

Why NG911 cares: NENA-STA-006.2a describes the PSAP boundary as the most critical layer and requires the provisioning boundary to be free of unintentional gaps or overlaps. In a gap, the ECRF has no PSAP to return. In an overlap, two PSAPs claim the same caller. Montana's 2024 readiness report makes a gap-free statewide PSAP layer one of its two headline readiness indicators.

-- Overlaps between PSAP polygons larger than 1 square metre
SELECT a.nguid AS psap_a, b.nguid AS psap_b,
       round(ST_Area(ST_Intersection(a.geom, b.geom))::numeric, 1) AS overlap_m2
FROM psap a
JOIN psap b ON a.nguid < b.nguid AND ST_Intersects(a.geom, b.geom)
WHERE ST_Area(ST_Intersection(a.geom, b.geom)) > 1;

-- Gaps: parts of the provisioning boundary no PSAP polygon covers
SELECT gap, round(ST_Area(gap)::numeric, 1) AS gap_m2
FROM (
  SELECT (ST_Dump(ST_Difference(p.geom, u.geom))).geom AS gap
  FROM prov p
  CROSS JOIN (SELECT ST_Union(geom) AS geom FROM psap) u
) g
WHERE ST_Area(gap) > 1;

The same test in GeoPandas, useful when the boundaries arrive as files from neighbouring agencies:

import geopandas as gpd

psap = gpd.read_file("ng911.gpkg", layer="psap").to_crs(32611)
prov = gpd.read_file("ng911.gpkg", layer="prov").to_crs(32611)

gaps = gpd.GeoSeries([prov.union_all().difference(psap.union_all())], crs=psap.crs).explode()
gaps = gaps[gaps.area > 1]

pairs = gpd.overlay(psap[["nguid", "geometry"]], psap[["nguid", "geometry"]], how="intersection")
overlaps = pairs[(pairs.nguid_1 < pairs.nguid_2) & (pairs.area > 1)]
print(len(gaps), "gaps,", len(overlaps), "overlaps")

Replace 32611 (UTM zone 11N) with the projected CRS for your area. The 1 m² tolerance is my choice. NENA's stewardship document (NENA-INF-028.2-2023) notes that no uniform precision standard exists yet and that unexpected gaps and overlaps can result from that, so pick a tolerance with your neighbours and your provider and write it down. Run the same pair of queries for the fire, police and EMS layers.

How do you turn these checks into a repeatable report?

Wrap each query in an INSERT into one table so the results become a single worklist:

CREATE TABLE IF NOT EXISTS qa_errors (
  check_no   int,
  layer      text,
  feature_id text,
  detail     text,
  run_at     timestamptz DEFAULT now()
);

INSERT INTO qa_errors (check_no, layer, feature_id, detail)
SELECT 5, 'rcl', nguid, side || ' side parity ' || parity || ' on ' || a || '-' || b
FROM (
  SELECT nguid, 'L' AS side, parity_l AS parity, fromaddr_l::int AS a, toaddr_l::int AS b FROM rcl
  UNION ALL
  SELECT nguid, 'R', parity_r, fromaddr_r::int, toaddr_r::int FROM rcl
) s
WHERE (parity = 'O' AND (a % 2 = 0 OR b % 2 = 0))
   OR (parity = 'E' AND (a % 2 <> 0 OR b % 2 <> 0));

Then the count per check per run is your progress chart, and the same script reruns after every edit session. That matters more than any single cleanup: NENA's stewardship guidance treats NG9-1-1 data as something maintained continuously, not fixed once.

What these checks will not catch

Automated QA proves internal consistency. It has limits worth knowing before you report a dataset as ready.

If you want these checks run against your county's data, or adapted to your state's schema and turned into a scheduled report, email me at mahad.imran29@gmail.com.

Frequently asked questions

How do I find overlapping address ranges on road centerlines?

Split each centerline into a left and a right side, each with a low and high address and a parity. Then self-join the sides on full street name and jurisdiction, keep pairs from different segments whose parities are compatible, and test whether the two number ranges intersect. In PostGIS the int4range type and the && operator make this a single query.

What does parity mean in NG911 road centerline data?

Parity records whether the address range on one side of a segment is odd, even, both or zero. NENA's GIS Data Model stores it in Parity_L and Parity_R with the domain O, E, B and Z, where Z means a 0-0 range. A parity error is a range coded odd that starts or ends on an even number, or the reverse. It breaks address interpolation and side-of-street placement.

Can I validate NG911 GIS data without ArcGIS?

Yes. PostgreSQL with PostGIS covers geometry validity, topology, range logic, spatial joins and boundary gaps, and GeoPandas covers the same ground in Python. The validation tool does not have to match the software your state or provider uses, because what they ingest is the exported schema. You still need your provider's own validator as the final check.

Should I fix NG911 GIS errors automatically?

Fix geometry problems such as invalid polygons or duplicate vertices automatically, then review the result. Do not auto-fix address ranges, parity, street names or boundaries. Those encode decisions by the addressing authority and neighbouring 911 agencies, and an automatic fix can move a call to the wrong PSAP. Flag them, assign each to a person, and record how it was resolved.

What coordinate system does NG911 GIS data have to be in?

Data loaded into the ECRF must be in WGS84: EPSG:4326 for 2D geometry and EPSG:4979 for 3D, according to NENA-STA-006.2a. You can maintain local data in any datum and projection, such as a State Plane or UTM zone on NAD83, as long as it is documented and transforms correctly. Run distance-based QA in the projected system, then transform for submission.

Let's talk.

Best way to reach me is email. I respond to most things.