Why AI urban planning gets stuck on data
A planner requests a passenger flow forecast for a new microdistrict, and the model responds with confident numbers that will not exist in reality.
The cause is almost always not the network architecture, but the quality of the source data: development, road network, and public transport route layers come from different agencies and are overlaid on each other with offsets of tens of meters.
The model trains on this stitching and produces a result with the same error, only now no one sees it with their eyes — it is hidden inside the forecast.
The root of the problem is different coordinate systems and different survey accuracy for each layer. One source provides geometry in a local system, another in a global one, and a third provides a raster basemap without alignment to current block boundaries.
Add to this mismatched update dates: parcel boundaries are current for one quarter, while the road network is current for another. Formally, AI urban planning receives a complete set of data; in fact, it receives a set of incompatible fragments.
Manual reconciliation finishes off the process. An engineer merges layers in an editor, corrects offsets, marks disputed areas — and so on for every district.
While they bring the data to a usable state, the original situation has time to change, and the forecast becomes outdated before it reaches a decision. The larger the territory, the more the layers diverge and the less time remains for the analysis itself.
We break down how this is closed: a unified spatial data model, automatic detection of discrepancies between layers, and quality control of source data before it enters training.
Measurable effect: approval timelines and forecast quality
The basic urban planning cycle runs into scenario preparation: collecting layers from different agencies, merging attributes, manually reconciling discrepancies.
This used to take weeks, and by the time the scenario was ready, some of the initial assumptions had already become outdated. After implementation, the same scenario is assembled in one to two days, and an edit to assumptions is recalculated without restarting the entire cycle.
Data errors are caught before calculation, not during scenario defense: geometry gaps, duplicate objects, discrepancies in address registries, missing layers, outliers in development density.
Each check has a rule and an explicit threshold, so the scenario either proceeds further or stops, indicating the specific area and layer. The share of datasets rejected by automation reaches up to two thirds of all comments.
Forecast robustness is ensured by running on multiple sets of assumptions: the output is a range of values, not a single number that is easy to dispute.
This eliminates a class of failures in which the model produces plausible indicators outside its applicability — for territories and development types poorly represented in the source data.
We compare the results with open industry microsimulation platforms, for example UrbanSim. If the discrepancy in density and street-road network load goes beyond a given corridor, the scenario returns for data refinement rather than going to approval with inflated confidence.
Deployment options: cloud, local environment, hybrid
The deployment scheme is chosen based on two constraints: where source data is allowed to be stored and what peak load must be sustained.
The cloud offers a quick start and elastic resources, a local environment removes concerns about exporting sensitive layers, and a hybrid scheme splits the flow between them. The difference shows not in model quality, but in request routing and how data is updated.
What actually differs between the schemes
| Option | When it fits | Limitations |
|---|---|---|
| Cloud | Regular layer updates, load varies by hour, a quick pilot start is needed | Data leaves the perimeter, there is dependence on the communication channel, some agency exports cannot be transferred |
| Local environment | Data must not be exported, in-house compute capacity exists, operation without an external network is needed | Resources are fixed, peak is sustained through reserve capacity, model updates occur on a schedule |
| Hybrid scheme | The sensitive part is closed, analytics and heavy calculations are outside | Two environments, data synchronization, separate access rules and logging |
Changing the scheme is replacing the storage and request routing layer, not rewriting the system. We fix data requirements before the start: formats, update frequency, owner, access mode.
What cannot be exported remains in the local environment; the rest we place where the load justifies it.
Order of work: from data audit to system handover
The order of stages matters more than it seems: a model assembled before a data audit shows beautiful numbers on demonstration datasets and falls apart on real blocks where some layers are outdated and some contradict each other.
Therefore, work proceeds from data inventory to system handover, and each step is closed with a result that can be verified.
- Data audit. We inventory layers: general plan and zoning, cadastre, traffic flows, resident requests, statistics on social infrastructure. We record update frequency, duplicates, gaps, and discrepancies between agencies — the output is a registry of sources with a suitability assessment.
- Integration scheme. We determine how data enters the system: regular exports, exchange via queues, requests to source services. For each source, we describe the owner, behavior during unavailability, and reconciliation rules.
- Target indicators. We agree on what exactly the system calculates — passenger flow, network load, development density — and what accuracy is sufficient for a decision.
- Model assembly and training. We assemble the calculation loop, train models, and compare the forecast with decisions actually made in historical periods.
- Model validation. We test on districts not involved in training and on incomplete data — this shows where the model extrapolates blindly. We review errors with domain specialists, not only by metrics.
- Pilot in a limited environment. The system operates in suggestion mode: the specialist decides, the system offers options and shows the rationale. This is how trust in conclusions is tested.
- System handover. We hand over documentation, data update and retraining regulations, train the customer's team, and support the first disputed results.
What we hand over: models, schemes, regulations
The work ends not with a model demonstration, but with the handover of a package by which the system can be developed without us.
Everything that describes model behavior, data rights, and update procedures remains in your code repository — not in chat and not in a developer's head.
- Model descriptions — the purpose of each model, input layers and features, permissible value ranges, quality metrics on a holdout sample, and applicability boundaries: where the forecast for development and transport load relies on data and where extrapolation begins.
- System documentation — service diagram, data path from sources to marts, connection points with your geoinformation environments, and export formats compatible with OpenStreetMap.
- Update regulations — frequency of layer ingestion, retraining conditions when data shifts, criteria for sending a model for additional training, and those responsible for launch.
- Access rights — a role model at the level of services, storages, and analytics dashboards: read, write, administration; a log of access to sensitive layers.
- Versioning — how previous weights and feature sets are stored, so rollback to previous behavior takes minutes rather than a rebuild.
- Operating procedure — forecast quality control, typical failures and responses to them, acceptance of a new data version.
- Development plan — validated and rejected hypotheses, the queue of next ones, so a new team does not start from scratch.
The package is self-sufficient: changes can be made by your own forces or handed to another team without restoring context.
How this works in practice: a mixed-use development district
The customer is an integrated territory development operator: a district of about 120 ha, four phases, strict requirements for social and transport infrastructure.
Before implementation, for each development option the team collected data manually: extracts from OpenStreetMap, cadastral boundaries, current regulations, layers of the existing network. Three layout options meant three weeks of work and 40–60 manual reconciliations for each.
What measurements showed before implementation
Most time went not into design, but into merging data. An error in setbacks from red lines or in development density was found only after the option was drawn, and part of the work went into rebuilding.
The team could not manage more than three scenarios — discussion revolved around what they had managed to calculate, not around the best solution.
What was changed and what resulted
We assembled a calculation core: geodata is loaded into a unified territory model, with a rule library on top (density, height, setbacks, insolation, places in schools and kindergartens, exit load).
An option is described by a set of parameters rather than a drawing, so a new scenario is calculated in minutes, and the result includes a report: which rule was violated and with what margin.
Scenario preparation shrank from three weeks to one to two days, the number of scenarios considered grew from three to twelve, and manual reconciliations were replaced by automatic regulatory checks.
Discrepancies with expert assessment on already built phases stayed within a few percent — and the model was calibrated against them.
What to do if AI services are already implemented but data does not match?
Data discrepancy rarely means that one of the systems has broken. More often, two parts of an operating system interpret the same object differently: address, cadastral number, zone status, approval date.
Therefore, integration diagnostics begins not with rewriting, but with finding the junctions where interpretations diverge.
First, we define the reference: we select 15–25 indicators that are calculated in both systems and compare them on the same slice — one district, one period, one list of objects.
Then we go along exchange boundaries and at each junction look at what is sent, what is received, and what changes during transfer: field format, reference data, recalculation rule, update moment.
In practice, the discrepancy is localized in one or two places, not spread across the entire scheme.
The operating system remains in service: we perform reconciliation on a copy, not on the production environment. We write integration logs in parallel and enable shadow intake — the new flow runs alongside the old one, results are compared, but no switchover occurs.
We recalculate history on archival exports to understand when the discrepancy appeared and what triggered it.
The output is a discrepancy map: where accuracy is lost, which rules contradict each other, what is fixed by editing a transformation, and what requires migrating reference data or changing the data owner.
Each change is checked on a control slice before being included in the working environment — so current processes do not stop for a single day.
Technical doubts: accuracy, privacy, support
Most questions before the start are not about the model itself, but about how we will prove its adequacy, who will get access to city data, and what will happen to the system a year after launch. Below are short answers to three doubts that technical leaders raise most often.
How can we be sure before launch that the forecast is accurate?
We validate on historical slices: take past periods, hide the actual result, and compare with it. We calculate error not as a single average figure, but by object classes and districts — an average of 8% can hide 30% in an industrial zone or on the periphery.
A holdout set of territories that the model did not see during training is mandatory: if quality drops on it, the algorithm memorized special cases instead of a pattern.
What happens to city data?
The system is deployed in the customer's environment; only aggregates go outside, not raw records. Personal data is de-identified before training — identifiers are replaced, address specificity is collapsed to blocks where this does not break the task.
Access is role-separated: an analyst sees layers and metrics, but not personal attributes, and every access to a dataset is written to a log.
Who is responsible for the model after launch?
Support is part of the work, not a separate service: we monitor divergence between input data and training data and catch forecast degradation before a planner notices it.
Retraining occurs on a schedule and by trigger — when new development or the route network changes the city's picture. Before each model replacement, we run regression checks on reference areas, and the previous one remains ready for one-action rollback.
Let's discuss the task: what to send for an accurate estimate
To return with an accurate estimate of work rather than a range "from and to," we need context on the data and system boundaries.
We will clarify some information ourselves with questions, but the list below removes most iterations and immediately sets a realistic implementation plan.
- Which decisions the system should support: checking development scenarios, forecasting transport load, assessing accessibility of social infrastructure, checking for contradictions with regulations.
- What already exists in terms of data: vector layers, registries, statistics, results of past surveys — in what form they are stored and how often they are updated.
- The quality and completeness of this data: where coverage is fragmentary, where attributes diverge, whether historical slices exist for training.
- Where to integrate the system: which geoinformation platform is used today, whether there is a storage, which reference data needs to be linked.
- Explainability requirements: how verifiable the answer must be, who and how will trace the conclusion back to the source layer.
- Constraints: personal data, restricted territories, who internally has the right to export and to view intermediate calculations.
- User roles: who formulates the request, who checks the result, who makes the decision on the scenario.
- Acceptance criteria: what share of calculations the system must cover without manual correction and in what time it must return an answer for a scenario.
With this set, we return with a work estimate and an implementation plan broken down by verifiable results: what you will see at each stage and by what criterion you will accept it. An incomplete list is not a problem — we will discuss the task and suggest what is missing.
