ArcGIS from Zero: make maps, build layers, share your work

Part 1Start here: what ArcGIS actually is

ArcGIS isn't one program — it's a family of tools made by a company called Esri, all built around the same idea: maps made of stacked layers of data. The two members you'll actually touch:

• ArcGIS Online — a website (arcgis.com). You make maps in your browser using a tool called Map Viewer. Nothing to install. This is where almost everyone should start, and it's where most of this guide lives.
• ArcGIS Pro — a heavy-duty Windows desktop application for serious data crunching, precise cartography, and print layouts. You graduate to it when the browser version can't do what you need. Part 8 covers the basics.

There are also mobile apps (Field Maps for collecting data outdoors, Survey123 for form-based collection) and app builders (StoryMaps, Dashboards, Instant Apps) — all of which consume the maps you build in Map Viewer. Learn Map Viewer and the rest of the family opens up naturally. Volume II covers both in depth.

What you need before you begin

An account. Three common situations:

• Your work or school gave you a login — you have an organizational account. You get everything, including saving, publishing layers, and analysis tools.
• You have nothing — sign up for a free ArcGIS public account at arcgis.com. You can make and save maps and create your own layers from files. Some premium content and analysis tools are off-limits, but everything in Parts 4–6 of this guide works.
• You just want to poke around — you can open Map Viewer without signing in at all. You can't save, but you can explore.

Part 2The big ideas

Five concepts explain 90% of ArcGIS. Get these and every menu in the software becomes predictable.

1. A map is a basemap plus layers

Picture an old-school overhead projector. The basemap is the bottom sheet — streets, terrain, or satellite imagery that gives everything context. Your layers are transparent sheets stacked on top: one sheet of dots for coffee shops, one sheet of lines for bus routes, one sheet of shaded shapes for neighborhoods. You can reorder the sheets, hide them, or adjust how see-through they are. That stack, saved with a name, is a web map.

2. Every layer is secretly a spreadsheet

This is the single most important idea in GIS. A layer isn't just shapes on a map — each shape has a row of data behind it, called its attributes. A dot representing a school knows its name, enrollment, and district. A county shape knows its population and median income. That hidden spreadsheet is called the attribute table, and it's why ArcGIS is more than a drawing program: you can color shapes by their data, filter them by their data, and do math on their data.

3. Data comes in two flavors: vector and raster

• Vector = shapes: points (a store, a tree, an incident), lines (roads, rivers, pipelines), and polygons (parcels, counties, lakes). Crisp at any zoom, each shape has attributes. Most of what you'll make is vector.
• Raster = a grid of pixels, like a photo: satellite imagery, elevation, rainfall surfaces. Great for continuous phenomena; individual pixels don't have rich attributes the way shapes do.

4. Layers live somewhere, and maps just point at them

When you add a layer to a map, you usually aren't copying the data — you're referencing a layer that lives in your account, your organization, or Esri's public catalog. Ten maps can point at the same layer; update the layer once and all ten maps update. The three places you'll pull layers from:

• My Content — layers you've made or uploaded.
• My Organization — layers your colleagues have shared.
• Living Atlas — Esri's huge curated public library: demographics, weather, boundaries, traffic, imagery, environment. Free to browse and use. When someone says "use available layers," this is usually the goldmine they mean.

5. Scale controls what you see

Layers can be set to appear only within a range of zoom levels (a "visible range"). A layer of every building in a country would be soup at world scale, so it's often configured to draw only when you zoom in. Remember this — it's the number-one cause of "my layer disappeared!" panic (see Part 18).

Part 3Layer types: what each one is for

ArcGIS has a zoo of layer types, and the names are intimidating until you realize each one answers a simple question: is it shapes or pixels, can you click it, and can you edit it?

Files you can turn into layers

These aren't layer types so much as raw ingredients — you upload them and ArcGIS converts them into (usually) feature layers:

• CSV / Excel — a spreadsheet with addresses or latitude/longitude columns becomes a point layer. The single most common way beginners create data. Full walkthrough in Part 5.
• Shapefile — the classic GIS exchange format. Confusingly, it's several files (.shp, .dbf, .shx, …) that must be zipped together before uploading. If someone "sends you a shapefile," zip the whole set.
• GeoJSON — a web-friendly text format for shapes. Upload as-is.
• KML / KMZ — Google Earth's format. Works, but styling control is limited.
• GPX — GPS tracks from watches and handheld units.

Which one do I pick?

Part 4Build your first map, end to end

This is the full journey: blank screen to saved, styled, shareable map, using layers that already exist. Budget 30–45 minutes the first time. Every click path below is written for the modern Map Viewer (the default since 2021 — if your screen says "Map Viewer Classic," switch to the new one from the app launcher).

Map Viewer's screen has two toolbars: the dark bar on the left (what's in the map: Layers, Basemap, Tables, Legend) and the light bar on the right (what you can do to the selected layer: Properties, Styles, Filter, Pop-ups, Labels). Left = contents, right = settings. That one sentence will save you a lot of hunting.

1. Sign in and open Map Viewer. Go to arcgis.com, sign in, and click Map in the top navigation. You'll land on a fresh map with a default basemap, usually centered on your region.
2. Pick a basemap. In the left toolbar, click Basemap. Choose the mood: Topographic for general purpose, Imagery to see the ground, Light Gray Canvas or Dark Gray Canvas when you want your data to pop and the background to whisper. You can change this any time — it doesn't touch your layers.
3. Add a layer that already exists. Click Layers in the left toolbar, then Add. A search panel opens. Use the dropdown at the top to switch between My Content, My Organization, and Living Atlas. Try Living Atlas and search something like "USA counties" or "world countries". Click + Add on a result and it appears on the map. Add two or three layers to get a feel for it.
4. Arrange the stack. Back in the Layers panel, drag layers up and down to reorder them (top of the list draws on top of the map). Click the eye icon to hide/show a layer. To make a layer see-through, select it, open Properties in the right toolbar, and drag the Transparency slider — handy for shaded polygons sitting over a basemap.
5. Style it — this is the fun part. Select a layer, then click Styles in the right toolbar. Two decisions:
   • Choose attributes — pick which column from the layer's data should drive the look (population, category, income…), or none.
   • Pick a style — ArcGIS suggests sensible options based on what you picked (this is "smart mapping"). The ones you'll use constantly:
     • Location (single symbol) — everything looks the same; you just want to see where things are.
     • Types (unique symbols) — a different color per category (zoning type, party, species).
     • Counts & Amounts (color) — a color ramp for numbers; darker = more. The classic "shade counties by income" look (a choropleth, if you want the fancy word).
     • Counts & Amounts (size) — bigger symbol = bigger number.
     • Heat map — for dense point data, shows concentration as a glow.
   Click Style options on any style to fine-tune colors, ramps, breakpoints, and outlines. Experiment freely — styling never alters the underlying data. (Part 9 goes much deeper.)
6. Configure pop-ups. Click any feature on the map and a pop-up appears showing its attributes — usually all of them, which is ugly. Select the layer, click Pop-ups in the right toolbar: set a meaningful title (you can insert field values with the {curly brace} picker), and trim the field list down to what a reader actually cares about. A good pop-up is the difference between a map and a data dump. (Part 10 adds images, charts, and formulas.)
7. Add labels. Select the layer, click Labels in the right toolbar, toggle Enable labels, and choose which field to label with (names, usually). Adjust font, size, halo, and the zoom range where labels appear.
8. Filter to just the features you want. Select the layer, click Filter in the right toolbar, and build a condition like Population is greater than 100,000 or Status equals Active. The map now shows only matching features. Filters are reversible — remove the condition and everything comes back.
9. Set bookmarks. In the left toolbar, Bookmarks → Add bookmark saves the current view (location + zoom) with a name, so you and your readers can jump between areas of interest.
10. Save it. Left toolbar → Save and open → Save as. Give it a clear title, a couple of tags, and a one-line summary. It now lives in Content (the tab in the main arcgis.com navigation) where you can reopen, duplicate, or delete it later.
11. Share it. Left toolbar → Share map. Three levels: Owner (private, default), Organization (colleagues with logins), Everyone (public link). If the map contains private layers, ArcGIS warns you and offers to update their sharing too — say yes, or viewers will see a broken map (this is the #1 sharing gotcha; more in Part 18). Copy the link and send it.
12. Optional: dress it up as an app. A raw web map link is fine for colleagues; for the public, wrap it in an app. From the map: Create app → Instant Apps, pick a template (Sidebar and Basic are safe starts), and you get a polished viewer with a legend, search bar, and your branding — zero code. Part 13 tours the whole app-builder family.

Part 5Create your own layers

Sooner or later the layer you need doesn't exist — it's your store locations, your survey sites, your project boundary. Four ways to make it, easiest first.

Option A — Draw directly on the map (Sketch layer)

For quick annotations: circling an area, dropping a few markers, drawing a route by hand.

1. Open the layer list — Layers → Add → Create Sketch layer (in newer builds: Add sketch).
2. Draw — pick a tool (point, line, polygon, text, arrow), click on the map to place vertices, double-click to finish a shape.
3. Style each sketch — color, outline, fill are per-shape. Save the map and the sketches save with it.

The catch: sketches are decoration. They live inside this one map, have no attribute table, and can't be analyzed or reused elsewhere. For real data, use options B or C.

Option B — From a spreadsheet (the most common path)

You have an Excel file or CSV of locations — customers, incidents, inspection sites. ArcGIS turns each row into a point.

1. Prepare the spreadsheet. One row per place, clean column headers in row 1. Location can be expressed two ways:
   • Coordinates — two columns named something recognizable like latitude / longitude (or lat/lon, x/y). Free and instant.
   • Addresses — columns like address, city, state, zip. ArcGIS looks each one up on the map — this is called geocoding, and on org accounts it costs a small number of credits per address.
2. Add it. In Map Viewer: Layers → Add → Add layer from file, then drag the file in. (Or from the Content page: New item → drag the file.)
3. Confirm the field mapping. ArcGIS guesses which columns hold the location and shows you its guess — check it. Choose whether coordinates or addresses drive placement, and confirm each field's type (text, integer, decimal, date).
4. Choose how to add it. You'll be offered to create a hosted feature layer (recommended — the data is uploaded to your account, reusable in any map, editable, shareable) or to add the file to this map only (quick, but a dead end).
5. Style, pop-ups, save — from here it's a normal feature layer; everything in Part 4 applies.

Option C — A blank layer you fill in by hand

No spreadsheet, no file — you want an empty layer with the fields you define, and you'll click features onto the map yourself. This is real data creation, and it's also exactly how field-collection apps work later.

1. Create the layer. Go to Content → New item → Feature layer → Create a blank layer. Choose the geometry: points, lines, or polygons. Name it well (you'll live with it).
2. Define the fields. Open the new layer's item page → Data tab → Fields → Add. For each piece of info you'll record, add a field with a type:
   • String — text (names, notes, categories)
   • Integer / Double — whole / decimal numbers
   • Date — dates and times
   For category fields (e.g., Condition: Good/Fair/Poor), add a list of values (a "domain") so editors pick from a dropdown instead of inventing spellings. Five minutes here saves hours of cleanup later.
3. Enable editing. On the item page → Settings tab → check Enable editing. (Layers you create are yours, but editing still has to be switched on.)
4. Add it to a map and start digitizing. Open a map, add your layer, then open Edit in the right toolbar. Choose your layer's template, click on the map to place a feature (for lines/polygons, click each corner, double-click to finish), fill in the attribute form, save. Repeat.
5. Fix mistakes. In the Edit panel, select any existing feature to move its vertices, update its attributes, or delete it.

Option D — Import GIS files someone gave you

Shapefile (zip the whole set of files first!), GeoJSON, KML, GPX: Content → New item → drag the file → choose Add and create a hosted feature layer. Done — it behaves like any other feature layer.

Option E — Collect data in the field

Once you've built a layer via Option C, the mobile story is nearly free: open ArcGIS Field Maps on a phone, sign in, open a map containing your editable layer, and crews can drop GPS-located points with photos and filled-in forms. Survey123 is the alternative when the form matters more than the map. Both feed the same hosted layers — the map back at your desk updates live. Part 14 walks through the full setup.

Part 6Edit your data: the attribute table

Remember the secret spreadsheet from Part 2? Here's how to work with it directly.

• Open it: in Map Viewer's Layers panel, click a layer's ⋯ menu → Show table. The table docks at the bottom; each row is a feature on the map.
• Table and map are linked: select rows and the matching features highlight on the map (and vice versa). Double-clicking a row zooms to that feature in most views.
• Sort and hide columns from each column's header menu to explore comfortably.
• Edit values: if the layer has editing enabled (yours will, from Part 5), click into a cell and type. Changes save to the hosted layer — every map using it sees the update.
• Add a column: on the layer's item page → Data tab → Fields → Add. New fields start empty; fill them in the table.
• Calculate a column: from a column's header menu, Calculate lets you fill every row with a formula (e.g., price / sqft) instead of typing row by row.
• Delete features: select rows → delete. This removes the shapes from the layer itself, not just the map — there's no undo on hosted layers, so pause before you pull the trigger.

Part 7A taste of analysis

Analysis tools answer spatial questions your eyes can't: what's within 10 minutes of here? which neighborhoods have the most incidents? where are the hot spots? In Map Viewer, select a layer and open Analysis in the right toolbar (org accounts with analysis privileges only — free public accounts don't get these). Each tool takes layers in and produces a brand-new layer out; your inputs are never modified. The five to know:

Part 8ArcGIS Pro in ten minutes

When do you actually need the desktop app? When you're processing large datasets, need precise control over projections and topology, want the full 1,500-tool geoprocessing arsenal, or are producing print-quality cartography. If none of that sounds like you yet, skip this part guilt-free — Map Viewer will carry you a long way.

The mental model

• Everything lives in a project (an .aprx file) — your maps, layouts, and connections in one bundle. Each project gets a home folder and its own geodatabase (.gdb) — a container where your layers live locally, playing the role ArcGIS Online's hosted layers play on the web.
• The ribbon (like Office) runs across the top; the Contents pane (left) is your layer list; the Catalog pane (right) browses your project's data and folders.

The core loop

1. New project — start with the Map template. You get a map with a basemap, ready to go.
2. Add data — Map ribbon → Add Data. Point at shapefiles, geodatabases, CSVs on disk — or sign in and pull the same ArcGIS Online / Living Atlas layers from Part 4.
3. Style — click a layer's symbol in Contents to open the Symbology pane. Same ideas as Map Viewer styles (single symbol, unique values, graduated colors), more knobs.
4. Create data — in Catalog, right-click the project geodatabase → New → Feature Class (Pro's name for a layer's dataset), choose point/line/polygon, define fields — the Part 5 Option C workflow, offline. Then digitize with the Edit ribbon → Create. Pro edits sit in a pending state until you hit Save Edits — the safety net Online doesn't give you.
5. Process — Analysis ribbon → Tools opens the geoprocessing pane: search any tool by name (Buffer, Clip, Spatial Join, Dissolve…), fill the form, run. Outputs land in your geodatabase. No credits — your own machine does the work.
6. Layouts for print — Insert ribbon → New Layout, pick a page size, add a map frame, legend, scale bar, north arrow, title. Export to PDF at print resolution. This is where Pro embarrasses every screenshot.
7. Publish to the web — Share ribbon → Web Layer or Web Map pushes your work to ArcGIS Online, where everything from Parts 4–7 takes over. Pro for production, Online for sharing: that's the standard division of labor.

Part 9Style like a cartographer

Part 4 covered the everyday styles. These are the techniques that make people ask "how did you make that?"

Clustering: taming thousands of points

A layer with 10,000 points is an unreadable smear. Clustering merges nearby points into a single bubble labeled with a count; zoom in and the bubbles break apart into individual points. Select the point layer → Aggregation in the right toolbar → Clustering. Adjust the cluster radius to taste, and configure the cluster pop-up to show a summary ("87 incidents here"). The sibling option, binning, divides the map into a honeycomb of cells shaded by count — better when you want a consistent statistical surface instead of bubbles.

Dot density: showing what's inside polygons

Shading counties by total population hides where people actually live. Dot density (a style option for polygon layers with counts) scatters dots inside each polygon — one dot per N people — so density becomes visible within areas, not just between them. Works beautifully with two or three attributes at once (e.g., dots colored by demographic group).

Relationship maps: two variables at once

Pick two numeric attributes and the Relationship style colors each area on a 3×3 grid — say, income (low→high) crossed with broadband access (low→high). One glance shows "high income but poor access" areas in a distinct color. It's the most analysis you can do with zero analysis tools.

Effects and blend modes

In Properties for a layer you'll find Effects (drop shadow, bloom, blur, grayscale) and Blending (how the layer's colors mix with what's beneath — multiply, overlay, and friends, like image-editor layer modes). Two restrained tricks that consistently look professional: a subtle drop shadow on your main polygon layer to lift it off the basemap, and multiply blending on a color-ramped layer over the Imagery basemap so terrain shows through the colors. Use one effect per map; three effects means the map is now about the effects.

Arcade: little formulas, big control

Anywhere Map Viewer lets you pick a field, it also lets you write an expression in a small formula language called Arcade — think Excel formulas for maps. Click Use expression (the </> icon) next to any field picker. The everyday use: style or label by a value that isn't a column. For example, if a layer has population and area_sqkm but no density column:

Round($feature.population / $feature.area_sqkm, 1)

$feature means "the feature being drawn." The expression runs live for every feature — no editing the data, no new columns, and it works on layers you don't own. Start by copying examples (the editor has a built-in library), change field names, and you'll be fluent in an afternoon.

Style by two channels at once

Smart mapping lets you drive color with one attribute and size with another (choose two attributes in the Styles panel, then pick Color & Size). Classic combo: circle size = total sales, circle color = year-over-year change. Two questions answered by one layer.

Part 10Pop-ups worth clicking: images, charts, and formulas

A default pop-up is a wall of field names. A configured one reads like a little report card for the feature. All of this lives in Pop-ups in the right toolbar, where the pop-up is assembled from stackable content blocks:

• Title — use a field, e.g. {SchoolName}, or combine: {SchoolName} ({District}).
• Fields list — the classic block; keep 4–8 fields, reordered by importance. Rename ugly column names with friendly display names (layer item page → Data → Fields) and set number formatting there too — thousands separators and sensible decimal places make you look careful.
• Text block — free-flowing sentences with fields dropped in: "{Name} served {Customers} customers in {Year}." Far more readable than a field list for narrative maps.
• Image block — shows a photo. Point it at a field containing an image URL, or at the layer's attachments (photos stored with each feature — enable attachments on the layer's item page → Settings; Field Maps photos land here automatically).
• Chart block — bar or pie chart built from several numeric fields of the same feature (e.g., population by age bracket). Surprisingly effective inside a pop-up.
• Arcade block — compute a value on the fly, same language as Part 9. Show a percentage that isn't stored anywhere: Round($feature.part / $feature.total * 100, 1) + "%".

Part 11The third dimension: Scene Viewer

Scene Viewer is Map Viewer's 3D sibling — same website, same layers, but with terrain, tilt, and buildings. Open it from the app launcher (the waffle icon) → Scene Viewer, or arcgis.com → Scene.

• Global vs. local: a global scene is the whole globe (regional and worldwide data); a local scene is a flat-earth cutout, better for a campus, a mine site, or indoor-scale work.
• Navigation: left-drag pans, scroll zooms, and right-drag tilts and rotates — the one gesture that makes 3D click. On a trackpad, two-finger drag tilts.
• Add the same layers you already have. Feature layers work in 3D out of the box: points become billboarded symbols, polygons drape on the terrain.
• Extrusion is the party trick: give a polygon layer 3D height driven by an attribute. Style a buildings layer with height = num_floors * 3.5 (yes, that's Arcade again) and a flat map becomes a city model. Same move works for statistics: counties extruded by population make a bar chart you can fly through.
• Scene layers (Part 3) are the pre-built 3D content: photorealistic city meshes, point clouds from laser scans. Search Living Atlas for "3D buildings" and add your city if it exists.
• Atmosphere: the daylight setting moves the sun by time-of-day and date — real shadows, which is occasionally analysis (shadow studies) and always drama.
• Save and share exactly like maps: scenes are items, and Instant Apps has 3D-capable templates.

Part 12Maps that move: time-aware layers

If a layer has a date field, ArcGIS can play it like a film strip: crime through the months, a storm's track, permits through a boom. Two steps:

1. Turn time on for the layer. Open the layer's item page → Settings → Time settings → enable, and tell it which date field marks each feature's moment (or start/end fields for durations).
2. Use the time slider in the map. Add the layer to Map Viewer, select it, and enable time from the layer's properties. A slider appears along the bottom: drag it, or press play to animate. Set the interval (days, months, years) to match your data's rhythm.

Everything else in the map respects the slider — pop-ups, filters, and styling all apply to the currently visible time window. Time works in Instant Apps and Dashboards too, so the animation survives into what you share.

Part 13From map to product: the app builders

A web map is raw material. The app builders wrap it in an interface designed for an audience. All of them are zero-code, all live under Content → Create app (or the app launcher), and all point at your web map — keep the map as the single source of truth and the apps update themselves.

Fast paths

• Instant Apps: from your saved map → Create app → pick Sidebar → toggle on legend, search, and layer list → Publish. Two minutes, genuinely.
• StoryMaps: storymaps.arcgis.com → New story. The blocks are self-explanatory; the one to learn is Sidecar, which pins a map while narrative panels scroll past — add map actions so each panel repositions the map.
• Dashboards: create from your map, then drag in elements. Each element (indicator, chart, list) points at a layer and can be wired so clicking a map feature filters everything else — that wiring ("actions") is what makes a dashboard feel alive.
• Experience Builder: start from a template, replace the placeholder map with yours, and resist the urge to use all forty widgets.

Part 14Fieldwork: collecting data out in the world

This is where Part 5, Option C pays off: the editable layer you designed becomes a mobile data-collection system with no extra engineering. Three apps, one decision:

Field Maps, end to end

1. Build the layer — Part 5, Option C: geometry, fields, dropdown domains, editing enabled. Also enable attachments (item page → Settings) so photos can be stored with each feature.
2. Make a map for the field — add the layer, style it simply (big symbols, high contrast for sunlight), save.
3. Tune the form — open Field Maps Designer (app launcher → Field Maps Designer), pick your map, and arrange the data-entry form: field order, required fields, conditional visibility ("show 'Damage description' only when Condition = Poor").
4. Prepare for offline — if crews leave cell coverage, define offline areas in Designer so the app pre-downloads the basemap and data for the work zone.
5. Collect — crews install the Field Maps app, sign in, open the map, tap +: GPS grabs the location, the form collects the facts, the camera adds photos. Offline edits sync when coverage returns.
6. Watch it land — back at your desk, the same hosted layer updates live. Put a Dashboard (Part 13) on it and you have a field operation with a control room.

Survey123 in one paragraph

Design a form (questions, logic, choices) on the web at Survey123's site; publish; respondents answer via a link or the app — no GIS knowledge needed on their end. Every response becomes a feature in a hosted layer, so results flow into maps and dashboards like anything else. Think "Google Forms, but every answer knows where it happened."

Part 15Manage your content like a professional

After a month of enthusiasm, your Content page is a junk drawer of "test," "test2," and "Untitled Map." Ten minutes of hygiene, repeated occasionally, keeps everything findable and safe.

• The item page is the command center. Every map, layer, and app has one (click its title in Content). Fill in the summary and description — future-you counts as a collaborator. Check the Usage tab to see whether anyone actually opens the thing.
• Folders and tags: folders for projects, tags for themes. Search works across both, but only if names are real ("Hydrant Inspections 2026," not "map3").
• Groups are how you share to some people. Owner/Org/Everyone (Part 4) is coarse. A group is a named circle — a project team, a committee — you share items into. Create one from the Groups tab, invite members, then share items to the group instead of the whole org.
• View layers: share a window, not the vault. From a hosted layer's item page: Create View Layer. A view is a controlled porthole onto the same data — you can limit which fields and features it exposes and make it read-only. The professional pattern: keep the master layer private and editable; make a public, read-only view for maps and apps. Editors touch the master; the world sees the view; there's one copy of the truth.
• Delete protection: item page → Settings → Prevent accidental deletion. Flip it on for anything load-bearing. Do it now; thank yourself later.
• Back up what matters: item page → Export data → File Geodatabase (or CSV/GeoJSON/shapefile) downloads a snapshot. Hosted layers are reliable, but the honest failure mode is you — a bad bulk edit or an overeager delete. Export before big changes.
• Delete safely: before deleting anything, check the item page for where it's used. Deleting a layer that a shared map depends on breaks the map silently for its viewers.

Part 16Coordinate systems without tears

You can go months without thinking about this — then two datasets refuse to line up and suddenly it's the only thing that matters. The whole topic compresses to a few honest paragraphs.

Two separate jobs get conflated. A geographic coordinate system (like WGS84 — the one GPS uses) defines where points sit on the curved Earth, in latitude/longitude. A projected coordinate system flattens that curve onto a plane so you can draw and measure it — and every flattening distorts something. Web maps almost universally use Web Mercator: great for navigation and tiling, terrible for comparing areas (it inflates regions far from the equator — Greenland looks the size of Africa; it's 14× smaller).

What this means in practice:

• In ArcGIS Online, mostly nothing. Layers are reprojected to match the map on the fly. This is why beginners never hit the problem.
• Measure with the tools, not with your eyes. Map Viewer's Measure tool computes geodesic (curved-earth) distances and areas, so it's right even though the display is distorted. Never estimate area by comparing shapes visually at continental scale on a web map.
• Misaligned data almost always means a mislabeled source. If a shapefile lands in the wrong place or offset by a consistent amount, its coordinate-system label doesn't match the actual coordinates inside. This is fixed in Pro, and the fix has a famous trap: Project (converts coordinates to a new system — use when the label is right and you want a different system) versus Define Projection (rewrites the label only — use when the label is wrong). Using Define when you meant Project makes the mess worse. Say it out loud before clicking.
• Working seriously in one region? Local projected systems (like State Plane or UTM zones) measure that region with minimal distortion — that's what surveyors and engineering datasets use, and why Pro users care about this daily.

Part 17Automation: when clicking stops scaling

The moment you catch yourself doing the same five-step process every Monday, ArcGIS has three escalating answers:

• ModelBuilder (in Pro) — a flowchart canvas: drag geoprocessing tools on, wire outputs to inputs, press run. Your five steps become one double-click, the workflow becomes a diagram a colleague can read, and no code is involved. This is the right first step for almost everyone. Analysis ribbon → ModelBuilder.
• Python — Pro's tools are all callable from Python (the arcpy library), and ArcGIS Online can be scripted with the ArcGIS API for Python — bulk-update items, batch-publish layers, refresh data on a schedule. ArcGIS Notebooks hosts these scripts right inside ArcGIS Online, no local setup. A pragmatic on-ramp: run a tool in Pro, then in the history panel right-click it → Copy Python command — the tool writes its own code for you.
• The layers themselves are APIs. Every hosted layer is a live web service with a URL (find it on the item page). Anything that speaks HTTP — internal apps, BI tools, scripts — can query features straight from it as JSON: no exports, no stale copies. When another team asks for "the data," sending the service URL instead of a spreadsheet is often the correct answer.

Part 18When things go wrong

Eight classic snags, in the order you're likely to meet them.

"I added a layer and see nothing."

In order of likelihood: (1) You're zoomed outside its visible range — select the layer and look for a "not visible at this scale" hint; zoom in or adjust the range in Properties. (2) The data is somewhere else on Earth — in the Layers panel, ⋯ → Zoom to. (3) The eye icon is off, or the layer sits under an opaque layer — check the stack. (4) A filter is hiding everything — check Filter.

"My CSV won't upload / points are in the wrong place."

Headers must be in row 1 with no merged cells or title rows above them. Coordinates must be decimal degrees (40.7128, -74.0060), not degrees-minutes-seconds — and mind the sign: western longitudes are negative. Points at (0°, 0°) in the Atlantic mean empty or swapped coordinate columns. Wrong-city geocodes mean the address field mapping needs fixing — include city, state, and zip columns.

"Pop-ups show nothing useful / show ugly field names."

Pop-ups display raw column names (POP_2020) until told otherwise. Configure them per Parts 4 and 10, and set friendly display names: layer item page → Data → Fields → click a field → edit its display name.

"I can't edit the layer."

Either it isn't yours and the owner didn't enable editing (most Living Atlas layers are read-only reference data — make your own copy if you need to change things), or it is yours and you skipped the switch: item page → Settings → Enable editing. If you're handed a read-only view (Part 15), edits belong on its master layer.

"I shared my map but people see an empty map or errors."

The map is public but the layers inside it aren't. Sharing is per-item: a public map pointing at private layers breaks for everyone but you. Reshare the map and accept the prompt to update the layers' sharing, or fix each layer on its item page. Apps add a third tier — app, map, and layers must all be shared.

"The map is slow."

Usually one layer with tens of thousands of complex features drawn at full-country scale. Set a visible range so detail appears only zoomed in, filter to the features you need, turn on clustering for dense points (Part 9), or (org accounts) publish the heavy layer as a tile layer for display.

"Two datasets don't line up."

A coordinate-system labeling problem — Part 16 has the diagnosis and the Project-vs-Define-Projection fix. Quick triage: a small consistent offset (meters) suggests a datum mismatch; landing in a different state or ocean means the label is flat-out wrong.

"Something ate my credits."

The usual suspects: geocoding a big address file, drive-time analysis, and storing large hosted layers. Check the estimate dialog before running analysis, prefer lat/long columns over addresses when you have them, and delete hosted layers you no longer need (from Content — check "used in" on the item page first so you don't break a live map).

Part 19Glossary

The words that get thrown around, in one place.

Arcade

ArcGIS's small formula language — Excel-style expressions used in styling, labels, and pop-ups to compute values on the fly.

Attribute / attribute table

The data behind a layer's shapes — each feature is a row, each property a column.

Basemap

The background reference map (streets, terrain, imagery) your layers sit on.

Blend mode

A rule for how a layer's colors mix with the layers beneath it, like image-editor layer modes.

Choropleth

A map that shades areas by a number — the "counties colored by income" look.

Clustering

Merging nearby points into count-labeled bubbles that split apart as you zoom in.

Credits

ArcGIS Online's currency, spent on storage, geocoding, and analysis. Viewing and making maps is essentially free.

Dashboard

An app pairing a map with live counters, charts, and lists — a monitoring screen for changing data.

Extent

The rectangle of the world a map or layer covers — "zoom to extent" means "show me all of it."

Feature

One thing in a layer: a single point, line, or polygon plus its row of attributes.

Feature class

ArcGIS Pro's term for a dataset of features stored in a geodatabase; becomes a layer when added to a map.

Field Maps

Esri's mobile app for map-centric field data collection and editing, with offline support.

Geocoding

Turning a text address into a map location. Costs credits in bulk.

Geodatabase (.gdb)

The container format ArcGIS Pro stores data in — a folder that acts like a database of feature classes.

Geodesic measurement

Distance or area computed on the curved Earth rather than the flat map — what the Measure tool does, and why it's trustworthy despite projection distortion.

GIS

Geographic Information System — the whole discipline of maps backed by data.

Hosted layer

A layer whose data lives in ArcGIS Online under your account, reusable across maps and apps.

Living Atlas

Esri's curated public library of ready-to-use layers — demographics, boundaries, environment, imagery, live feeds.

Pop-up

The info card that appears when you click a feature.

Projection / coordinate system

The math for flattening the round Earth onto a flat map. Web maps almost always use "Web Mercator"; Part 16 covers the rest.

Raster

Pixel-grid data — imagery, elevation, surfaces.

Scene

The 3D counterpart of a web map, built and viewed in Scene Viewer.

Shapefile

A veteran file format for vector data; ships as several files that travel together in a zip.

Symbology

The rules for how a layer is drawn — colors, sizes, ramps. "Styling," formally.

Time-enabled layer

A layer with a designated date field, playable through the time slider.

Vector

Shape data: points, lines, polygons.

View layer

A controlled window onto a hosted layer — same data, restricted fields/features/permissions. Share the view, protect the master.

Visible range / scale range

The zoom levels at which a layer draws. The usual culprit when a layer "disappears."

Web map vs. web app

The web map is the saved stack of basemap + layers + styling. An app (Instant App, StoryMap, Dashboard) is a friendlier wrapper around a web map for end users.

---

Where to go from here

You now know more than enough to be dangerous. Three good next moves: rebuild a map you've seen at work from scratch (fastest way to make Part 4 stick); take a real spreadsheet you own through Part 5 Option B; and browse Living Atlas for twenty minutes — knowing what already exists changes what you'll think to build. When you want structured practice, Esri's free Learn ArcGIS site has guided, real-data lessons for every topic in this guide.