AA Essentials cheat sheet

Automation is the execution of a predefined rule or process by a system with minimal human intervention; it replaces repeatable manual steps, not judgment.

Deterministic automation produces the same output for the same input every time; non-deterministic automation (e.g., model-based) may vary, so validate outputs before acting on them.

Trigger types: event-driven (fires on a change such as a new record), schedule-driven (fires on a time interval), and manual (fires on user action).

Idempotency means running the same automation twice yields the same end state; it is required for safe retries and at-least-once delivery.

A workflow is a sequence of steps with defined inputs, outputs, branches, and error paths; a process is the human or business activity the workflow models.

Rule of thumb: automate high-volume, low-variability, rule-based tasks first; keep high-variability, judgment-heavy tasks human-in-the-loop.

ROI of automation = (time saved per run x runs per period x labor rate) - (build cost amortized + run cost + maintenance cost).

Common failure modes: brittle selectors, unhandled exceptions, missing rate limits, and silent failures with no alerting or audit log.

Human-in-the-loop approval is a control, not a step to skip: route exceptions and high-impact actions to a person for confirmation.

A model is a function with learned parameters that maps inputs to outputs; training adjusts parameters to minimize a loss on labeled or unlabeled data.

Supervised learning uses labeled examples; unsupervised learning finds structure without labels; reinforcement learning learns from reward signals over actions.

Classification predicts a discrete label; regression predicts a continuous value; choose based on the target variable type.

Training data is split into train, validation, and test sets; the test set is used once at the end to estimate generalization, never for tuning.

Overfitting: low training error but high validation error; mitigations include more data, regularization, and early stopping.

A large language model predicts the next token from context; its output is probabilistic, so prompts, temperature, and evaluation materially change results.

Hallucination is confident output not grounded in source data; grounding (retrieval-augmented generation) and citations reduce but do not eliminate it.

Precision = TP / (TP + FP); recall = TP / (TP + FN); the trade-off is set by the threshold and by the cost of each error type.

Bias in, bias out: model behavior reflects training data and label choices, so data provenance and representativeness are correctness concerns, not just ethics.

Start from a written spec: trigger, inputs, ordered steps, decision branches, outputs, and error handling; ambiguous specs produce silent failures.

Use credentials stored in a secrets manager or vault, never hardcoded in scripts or workflow definitions; scope each credential to least privilege.

Wrap external calls in retry with exponential backoff plus jitter; cap attempts and treat non-idempotent calls carefully to avoid duplicates.

Validate inputs at the boundary (type, range, required fields) and fail fast with a clear error rather than propagating bad data downstream.

Log each run with correlation ID, timestamp, input hash, outcome, and duration; log identifiers and status, not sensitive payloads.

Branch on explicit conditions and define a default path; every branch needs a defined terminal state so runs cannot hang.

Test with a dry-run mode against sample data, then a staging environment, before enabling the production trigger.

Set timeouts on every step and a max runtime for the whole workflow; a hung step should escalate, not block the queue indefinitely.

Keep automations small and composable; a single-purpose workflow is easier to test, monitor, and reuse than one large monolith.

Governance layers: an inventory of automations, an owner per automation, a change-approval process, and periodic review for stale or orphaned bots.

Segregation of duties: the person who builds an automation should not be the sole approver of its production deployment for high-impact processes.

RPA bots and API integrations differ: UI-level bots are brittle to interface changes, while API integrations are stable but depend on system support.

Auditability requires immutable run logs retained per policy, with traceability from a business outcome back to the automation run that produced it.

Change management: version-control workflow definitions, document rollback, and re-test after any upstream system or credential change.

Key metrics: straight-through processing rate, exception rate, mean time to recovery, cost per transaction, and hours saved per period.

Business continuity: automations that touch critical processes need a documented manual fallback and monitoring that alerts on missed runs.

Data handling: classify data touched by the automation and enforce retention, access, and residency rules before connecting to external services.