First deployment checklist
Use this after building an app and before inviting people to rely on it. A working tutorial or successful upload is a starting point; readiness depends on the behavior of your deployed app with its actual rules and users.
For the underlying model, read how an application fits together. Apply write, ownership, automation, and live-update checks only when your app has those features. Mark an omitted check Not applicable with a reason.
1. Choose the host and record what you will publish
- Follow onboarding for account and tool setup. Select the intended host in the console and record its actual serving URL. Use a separate test host and harmless fixture data to exercise changes before publishing real information.
- Use the host's own authoring details. The WebDAV mount is the live site; saving a file there changes live content. Keep authoring credentials and API keys in trusted tools, outside served HTML, browser bundles, screenshots, and review records. Visitor access must use the app's supported identity and permission flow.
- Record the application release or source commit, format/schema version, rules/configuration revision, relevant content revision, date, and maintainer. Record the deployed platform version and feature configuration when available; otherwise write not exposed. A feature in the reference or an advertised method does not establish its availability on this host.
2. Define source, ownership, and allowed operations
List each source resource, stable element identity, editable properties, types and bounds, owner, and allowed operations. Distinguish stored domain information from templates, composed views, temporary controls, and local drafts. Keep semantic HTML as the editable domain source rather than adding a parallel editable JSON model.
For each editable view, identify the addressed resource, source origin, selector, and validator scope. Supported include write-through authorizes against the addressed composed page while validating and saving in the origin. An arbitrary rendered element is not automatically an editable source.
Decide which content is public, shared, or private. The first-app tutorial deliberately allows shared anonymous edits. The users and authenticated actors mean every signed-in person, not the owner of a particular item. Use authorization rules and, where appropriate, group permissions to express your actual access policy.
3. Publish definitions and policy with harmless data first
Use your supported authoring workflow to publish the reviewed documents, templates, scripts, authorization rules, and applicable schemas and shapes. Confirm their effective behavior before adding private information or inviting visitors. Do not assume a sequence of file uploads activates as one atomic release.
WebDAV deliberately bypasses application schemas, constraints, and handlers and has its own authentication. Its successful save is not a validation result. Check the app through its actual serving URL and application write path, without supplying the author's privileged credentials.
Do not rely on missing rules: unmatched GET/HEAD reads depend on the host's default-GET mode, while an unmatched SSE subscription is denied. Review the matching model and observed behavior on your host.
4. Exercise the app as the intended people
Use separate anonymous, permitted, and unrelated signed-in sessions as relevant. Exercise direct document and fragment access as well as composed pages. A source hidden from direct reads can still be exposed by a public composed view. Try the documented requests independently of the interface; a disabled button is not enforcement. If the app retains private content in client caches or offline storage, define what may remain after sign-out or account changes and check that policy.
For apps that accept writes, save and failure recovery provides a focused conditional-PUT example. Check the actual app's operations:
- Save a harmless valid change and read it back in a fresh view. Confirm the intended source changed and unrelated information did not. Check form serialization: current
valueandcheckedproperties do not automatically appear inouterHTML. - As an unauthorized actor, attempt an otherwise valid operation and confirm that access is refused.
- As an actor permitted to write that target, submit invalid values or markup through the application path. Confirm validation refusal and inspect the affected source for unintended changes. Restrict executable markup and policy/composition directives in user input using the supported validation contract; parsing HTML alone does not make it safe.
- Keep a draft in two sessions, save one, then attempt a stale conditional save in the other. Follow the supported PUT concurrency contract; a specific stale
ETaginIf-Matchshould produce412, preserving the first save and the second person's recoverable draft. - Exercise a failed or interrupted save. Distinguish confirmed state, newer draft edits, and the frozen pending submission. A lost response leaves the outcome unknown: reconcile before retrying an operation that could duplicate or overwrite data. Do not invent a universal receipt or retry guarantee.
Where configured, check triggers and processors, including earlier independent effects and failures after the main save. Do not assume all effects roll back together. For SSE, check incoming changes, dirty drafts, reconnection/reset recovery, and sign-out or account changes. Incoming updates must not silently erase or re-save a draft.
Complete the main task by keyboard, with meaningful labels, visible focus, and readable saving/error states. Check the actual supported browser and agreed content-size, composition, and response-time limits. Record gaps instead of counting these checks as passed because the page loaded.
5. Protect live content and rehearse recovery
Identify exactly which files the release owns and which hold user-managed content. Save a recoverable copy of what you intend to replace. Exercise restoration or forward repair on the test host, preserving newer user edits; rolling code back does not undo changed data. Avoid re-uploading an old whole-page tutorial file over a live list.
After publishing, re-check the served page, permissions, and a harmless supported operation on the intended host. Record which release/configuration was observed. Clean up fixture data through supported operations without removing real content, and retain the review record. If a required check fails or remains pending, resolve it or keep the affected capability unavailable before inviting people to use it.
6. Keep a deployment record
Store this record alongside the application's maintained documentation. Name the reviewer and date for each result, link to evidence, and exclude secrets and private payloads. These rows are a template, not executed checks.
| Check | Expected result | Observed result and evidence |
|---|---|---|
| Release, host, and capabilities | Intended serving URL, release/configuration, format and content revisions identified; unknown platform version labeled. | Record reviewer/date and evidence. |
| Read access | Public content readable; private source and derived views protected from unintended actors. | Record actors and targets. |
| Write access, if used | Permitted operation succeeds; anonymous/unrelated actor denied where policy requires it. | Record actors, operation, and target. |
| Validation, if the app accepts writes | Invalid content refused on application path; authored content separately reviewed. | Record input and source observations. |
| Persistence and concurrency, if used | Accepted change survives a fresh read; stale conditional write refused; draft retained. | Record operation, validator scope, and outcome. |
| Failure and retry, if used | Pending/draft information retained; unknown outcomes reconciled before unsafe retry. | Record failure and recovery. |
| Automation and live updates, if used | Actual effects understood; drafts protected; gap and session recovery work. | Record scenarios, or reasoned Not applicable. |
| Accessibility and limits | Main task usable with keyboard and readable status; agreed support and workload limits checked. | Record browser, task, and limits. |
| Release and recovery | User content preserved; scoped recovery rehearsed; published behavior re-checked. | Record replaced files and recovery evidence. |
Keep the record with this release's evidence. Repeat affected checks when rules, templates, dependencies, or supported workflows change.