mcorbett51090/RavenClaude - Page 19

quantify-labor-and-turnover

Read labor cost, agency reliance, and turnover as quantified unit economics, since they drive both margin and quality. Reach for this on a cost question.

read-quality-and-compliance

Read survey readiness, incidents/falls, and quality measures as existential operational risk, as decision-support. Reach for this on a quality question.

staff-to-acuity-ppd

Build a staffing model on acuity-weighted hours-per-resident-day, not a fixed ratio, so labor matches need. Reach for this on a labor question.

build-flat-rate-book

Build a flat-rate price book from loaded labor and real material cost with good/better/best options, so service pricing protects margin. Reach for this on service pricing.

build-the-loaded-rate

Build a billable labor rate that absorbs wage, burden, vehicle, tools, insurance, and overhead, so every hour sold makes money. Reach for this before any estimate or flat-rate book.

cut-callbacks

Read first-time-fix and quantify the callback labor cost, then fix truck stocking and diagnosis, since a callback is a free truck roll. Reach for this when callbacks are high.

raise-billable-efficiency

Read the billable-hour ratio and cut non-billable drive, restock, and rework time, since billable efficiency is the field's master number. Reach for this on a productivity question.

read-the-sales-levers

Read close rate and average ticket and option-presentation, since they move revenue more than lead volume. Reach for this before spending on marketing.

design-care-protocol

Build an evidence-aligned, standardized care protocol as decision-support for the licensed DVM, to reduce unwarranted variation. Reach for this on a common presentation worked up inconsistently.

instrument-production-and-act

Read practice revenue as production per DVM and average client transaction × visits, never one alone, so a revenue problem is diagnosed correctly. Reach for this on any revenue question.

lift-care-compliance

Read recommended-care acceptance as a communication metric and raise it, instead of treating it as fixed demand. Reach for this when acceptance of dentals/diagnostics/preventives is low.

reprice-the-fee-schedule

Reprice fees from the cost-of-service stack and medical value, not the neighbor's prices, to recover margin without losing position. Reach for this when margin erodes despite volume.

unlock-schedule-capacity

Find the doctor bottleneck and fix the appointment template so a fully-booked practice can grow throughput. Reach for this when revenue is flat despite full demand.

data-quality-testing

Keep the warehouse trustworthy: dbt tests (not_null/unique/accepted_values/relationships) gating the build in CI, source-freshness checks, model contracts at consumer boundaries, singular tests for business invariants, and anomaly detection beyond schema…

dbt-modeling

Model in dbt across staging -> intermediate -> marts layers, choose materialization (view/table/incremental) by the trade, write correct incremental models (reliable unique key, is_incremental filter, late-data strategy), and keep it DRY with…

semantic-metrics-layer

Build a governed semantic/metrics layer: define each metric once as metrics-as-code (dbt Semantic Layer/MetricFlow) with explicit grain and filters, model entities/dimensions to prevent fan-out, and expose one contract every BI tool consumes — ending metric…

aws-account-strategy

Design a multi-account AWS landing zone: separate accounts by blast radius (prod/non-prod/security/shared-services) under Organizations, SCP guardrails as ceilings, region/AZ resilience, and the Control-Tower-or-not decision.

aws-compute-selection

Choose AWS compute by workload shape and operational burden: Lambda (event/spiky), Fargate/App Runner (containers, no cluster ops), EKS (k8s/portability), EC2 (legacy/specific); design event-driven integration with idempotency and DLQs.

aws-finops

Control AWS cost: cost allocation tags from day one, budgets + anomaly detection, rightsize before committing to Savings Plans/RIs, tested backups, and continuous zombie-resource cleanup.

aws-least-privilege-iam

Write least-privilege AWS IAM: scope actions and resource ARNs to exactly what's needed, attach to roles (not users/keys), prefer federation (IRSA/OIDC) and Identity Center, and cap with permission boundaries + SCPs.

backend-implementation

Implement business logic cleanly: keep the framework at the edges with logic in testable use-cases, model errors explicitly (expected vs bug), validate inputs into domain types at the boundary, add idempotency keys for retried operations, and use the outbox…

backend-resilience

Make the backend survive its dependencies: timeout every outbound call, retry idempotent-only with exponential backoff + jitter, add circuit breakers and bulkheads, define a graceful-degradation mode, and design idempotent background workers with DLQs and…

caching-and-data-access

Own the data-access layer: queries behind a repository, short explicit transaction boundaries (never across HTTP), kill ORM N+1 by eager-loading/batching, and cache-aside with a defined invalidation trigger plus stampede (single-flight) protection.

service-boundary-design

Decide backend structure: default to a modular monolith, split into services only for a concrete need (scaling, team autonomy, deploy/runtime isolation), draw boundaries by bounded context (each owning its data), and choose sync vs async per seam.

container-hardening-k8s

Build a small, safe container for Kubernetes: multi-stage with a distroless/minimal base, non-root UID, digest-pinned base, dropped Linux capabilities, and a read-only root filesystem.

ingress-and-mesh

Design cluster networking: Gateway API ingress for north-south, and a service mesh ONLY when it earns its complexity (mTLS-everywhere, traffic-splitting, per-call resilience). Wire mTLS, weighted canary routing, and resilience deliberately.

k8s-platform-ops

Operate a safe multi-tenant cluster: namespace-per-tenant with scoped RBAC (no workload cluster-admin), default-deny NetworkPolicies, resource quotas/LimitRanges, policy admission control, and tested PDB-respecting upgrades.

k8s-workload-design

Design a Kubernetes workload: choose the workload kind by statefulness, set the three probe types correctly, requests/limits with the resulting QoS class, HPA/VPA on a load-tracking signal, and a PodDisruptionBudget.

catalog-and-lineage

Build a maintained data catalog: automated sensitive-data/PII discovery and column-level tagging, end-to-end lineage captured from pipeline/dbt metadata, a business glossary tying terms to tables, and surfaced access for governance.

data-classification

Design and apply a usable data classification scheme: a small set of levels (public/internal/confidential/restricted) plus a PII/sensitive flag, handling rules per level, and a mapping to enforceable controls — governing the highest-risk data first.

kafka-platform

Run the streaming platform reliably: partition for the ordering you need (order is per-partition; the key is the guarantee), govern schemas with a registry + compatibility rules, configure producer durability (acks/idempotence) and consumer…

stream-processing

Process streams correctly: aggregate on event-time with watermarks (not processing-time), window deliberately (tumbling/sliding/session), handle late data explicitly, checkpoint and TTL-bound state, join with aligned time, and design for backpressure.

streaming-vs-batch

Decide streaming vs batch honestly by the real latency need (sub-minute reaction -> streaming; hourly/daily -> batch via data-platform), then design the topology, platform choice, and delivery semantics if streaming is justified.

db-reliability

Operate the database reliably: pool connections with sane limits, choose the isolation level deliberately (knowing its anomalies), keep transactions short, route replica reads carefully, and test restores — a backup is only real if you've restored it.

query-and-index-tuning

Tune queries with evidence: read EXPLAIN (ANALYZE, BUFFERS) first, choose the right index type and column order (B-tree/partial/composite/covering/GIN), rewrite to be sargable, kill N+1 at the SQL level, and keep statistics fresh.

relational-schema-design

Design a correct relational schema: normalize to 3NF, denormalize only with measured evidence and a named consistency cost, push constraints (PK/FK/UNIQUE/CHECK/NOT NULL) into the database, and choose precise data types.

safe-schema-migrations

Evolve schemas without downtime: expand/contract (add -> backfill in batches -> switch -> drop) across separate deploys, lock-aware DDL (create indexes CONCURRENTLY, nullable-add-then-validate), reversibility, and ordered versioned migrations.

ci-pipeline-design

Design a fast, deterministic CI pipeline: stage ordering by cost, dependency/build caching keyed on the lockfile, build matrices and test sharding, required-check contracts for branch protection, and SHA-pinned third-party actions.

gitops-delivery

Stand up GitOps continuous delivery with Argo CD or Flux: desired-state-in-Git repo structure (app-of-apps, environment overlays), promotion-by-PR, drift detection/self-heal posture, and secrets without plaintext.

progressive-delivery

Choose and wire a progressive-delivery strategy — blue-green, canary, rolling, or feature-flagged — by blast radius and reversibility, with a health-gated promotion and an automated, rehearsed rollback.