ArcGIS Developer Foundation study plan

Map the full ArcGIS Developer Foundation blueprint into a one-page checklist that lists every named platform component (maps and scenes, layers, portal items, authentication, REST services) and mark each as known, shaky, or unknown.

Set up a free ArcGIS Developer account and confirm you can sign in to the developer dashboard, open the API key and OAuth credential pages, and locate the documentation and sample-code sections without help.

Install and configure the two client environments you will use all course long (for example ArcGIS Maps SDK for JavaScript with a local dev server, plus either the ArcGIS Maps SDK for Python or the REST/ArcGIS REST JS tooling) and verify each renders or queries a public basemap.

Write a short glossary of 15 core terms (web map, feature layer, tile layer, vector tile layer, spatial reference, geometry, symbol, renderer, popup, portal item, API key, OAuth 2.0, token, REST endpoint, query parameters) in your own words.

Explain how the ArcGIS platform is layered (data and services, portal and identity, client SDKs, apps) and describe in writing which layer owns which responsibility for three sample scenarios.

Compare API key authentication with OAuth 2.0 user authentication and with app-level tokens, and state for each which use cases it fits and which it must not be used for.

Register an application in the developer dashboard, configure a redirect URI, and complete a working OAuth sign-in flow in your client environment that displays the signed-in user's name.

Identify the security and quota pitfalls of embedding credentials in client-side code and document the mitigation you applied in your own project.

Create a web map and a feature layer in your portal, publish it, and confirm you can consume it from your client environment by item ID rather than by hard-coded URL.

Distinguish feature layers, map image layers, tile layers, vector tile layers, and imagery layers by query capability, rendering behavior, and typical use, and record the comparison in a table.

Render the same dataset with at least two different renderers (for example a simple symbol renderer and a class-breaks or unique-value renderer) and configure popups that show chosen fields.

Query a feature layer with a where clause, an out-fields list, and a spatial filter, and log the returned geometry and attributes to confirm you understand the response shape.

Read the REST API documentation for the feature service query operation and list every parameter you would need for paging, ordering, and returning geometry.

Call a public feature service directly over HTTP and reproduce the same result you got through the SDK, then note where the SDK abstracted work away for you.

Handle pagination and result limits correctly by implementing exceeded-transfer-limit or offset-based paging in a loop that retrieves a full dataset.

Implement error handling for at least three failure modes (invalid token, malformed query, service unavailable) and show the messages your app surfaces.

Load a geometry, project it between two spatial references, and verify the transformed coordinates against a known reference point.

Perform a client-side spatial operation (buffer, intersect, or nearest) and, where a geometry service is required, call it and compare the result.

Build a small editing workflow that adds, updates, and deletes features in a hosted feature layer, and confirm the changes persist after reload.

Validate input geometries before submission and reject at least one invalid case (self-intersecting polygon or out-of-range coordinate) with a clear message.

Configure a web map's widgets and settings in the portal and confirm the client app honors those settings without extra code.

Add at least three interactive widgets (for example search, legend, basemap gallery, measurement, or layer list) and wire each to the correct view.

Implement a responsive layout that works at desktop and narrow mobile widths and verify with your browser's device emulation.

Profile load behavior and reduce initial requests by loading layers on demand or deferring non-critical widgets.

Write automated tests for your data-access layer that mock service responses and assert correct parsing, paging, and error handling.

Add structured logging and a simple health check so failures in authentication or service calls are diagnosable.

Review your code against the platform's documented best practices for credential handling, and remove any secret from source control, moving it to environment configuration.

Document the deployment steps for your app so another developer could reproduce your environment from the repo alone.

Re-rate every item on your week-one blueprint checklist and drill only the items still marked shaky or unknown.

Complete a timed practice run of scenario-style questions covering authentication, layer types, REST queries, geometry operations, and portal configuration, and log every miss with a one-line reason.

Rebuild one core workflow from memory (authenticate, load a layer by item ID, query, render, edit) without consulting notes, then compare against your notes and fix gaps.

Consolidate your glossary, comparison tables, and error-handling notes into a single two-page reference sheet you can review in the final days.