MitchellCo Notes

Ideas worth testing.

Practical notes on product management, AI, analytics, robotics, technical systems, and execution. Short enough to read, specific enough to use.

The Maintenance Window Is a Product Promise

Turn planned maintenance into a clear product contract with precise scope, customer choices, live states, verification, and a durable completion record.

Backups Need a Restore Contract

A backup product should prove what can be restored, how long recovery takes, which dependencies matter, and whether the result actually works.

Admin Impersonation Should Never Look Normal

Admin impersonation should use bounded sessions, unmistakable visual state, dual attribution, and a clean exit instead of borrowing a customer identity.

Bulk Imports Need a Reconciliation Receipt

Bulk import products should preview changes, quarantine invalid rows, and issue a durable reconciliation receipt that explains every outcome.

Geofence Alerts Need a Dwell Clock

Reliable geofence products combine boundary geometry, location uncertainty, dwell time, and evidence instead of treating every coordinate crossing as truth.

Heat Pump Products Need a Defrost Story

Heat pump products should explain defrost, auxiliary heat, and faults as distinct operating states instead of leaving owners to decode a blinking icon.

Battery Health Is Not a Percentage

Battery products should separate usable energy, power capability, uncertainty, and operating limits instead of hiding health behind one percentage.

Machine Vision Products Need a Lighting Contract

Machine vision products need measurable lighting limits, image-quality checks, and recovery rules before model accuracy becomes an operating promise.

RFID Products Need a Read-Zone Contract

RFID products need explicit read-zone, transition, confidence, and reconciliation rules before a tag observation becomes inventory truth.

Connected Products Need a Clock Contract

Connected products need rules for clock accuracy, offline timestamps, event ordering, and recovery before device time becomes operational evidence.

Predictive Maintenance Needs a Failure Horizon

Predictive maintenance alerts should reveal whether a team has enough time to plan a safe intervention, not merely detect an anomaly.

Formal Verification Needs a Proof Boundary

Formal verification becomes a trustworthy product claim when teams publish the model, assumptions, properties, evidence, and limits behind the proof.

Maritime Alerts Need More Than One Witness

Maritime awareness products should preserve sensor provenance, corroborate contacts, and show disagreement before they escalate an alert.

Every Webhook Needs a Delivery Receipt

Webhook products need visible delivery receipts, replay controls, and reconciliation tools so customers can recover from missed events.

Robotics Products Need a Calibration Ledger

A calibration ledger connects each robot result to the sensor, method, uncertainty, and approval that made the measurement trustworthy.

AI Agent Context Needs an Eviction Policy

AI agents need explicit rules for pinning, summarizing, and evicting context so long-running work stays accurate, affordable, and auditable.

AI Agent Queues Need Backpressure

AI agent queues need admission limits, honest wait states, and fair scheduling so accepted work does not become a promise the system cannot keep.

AI Agent Approvals Need an Expiration Date

AI agent approvals should expire when their action, context, or risk changes. Bind every decision to exact inputs and require revalidation.

An AI Agent Stop Button Must Stop the Work

Stopping an AI agent should cancel owned work, preserve completed effects, run cleanup, and leave a durable receipt users can trust.

Voice AI Should Know When to Yield

Voice AI feels natural only when it handles pauses and interruptions well. Give every conversation an explicit turn-taking policy.

AI Agent Tools Need an Idempotency Contract

Agent retries can duplicate charges, tickets, and orders. An idempotency contract makes uncertain outcomes safe to inspect and repeat.

Observability Needs a Sampling Budget

Telemetry volume is not observability. Build a sampling budget that protects rare failures, controls cardinality, and ties retention to decisions.

Vision AI Needs an Abstention Lane

A vision model should not force every image into an answer. Design an abstention lane with review rules, thresholds, and measurable costs of operation.

Multi-Agent AI Needs a Delegation Budget

Multi-agent AI can improve difficult work, but every handoff adds cost and uncertainty. Set a delegation budget tied to measurable outcome gains.

Peak TOPS Are a Poor Edge AI Product Promise

Peak TOPS hide heat, power, and enclosure limits. Define an edge AI product around sustained inference latency under real operating conditions.

Robot Simulators Need a Fidelity Budget

A robot simulator needs a fidelity budget that ties physics, sensors, timing, and world detail to the product decision being tested.

Multi-Robot Fleets Need a Traffic Contract

A multi-robot fleet needs a traffic contract for intent, right of way, stale data, deadlocks, shared infrastructure, and safe recovery.

Digital Twins Need an Authority Boundary

A digital twin needs an authority boundary that separates observation, prediction, recommendation, approval, and control of the physical system.

Model Tuning Needs an Exit Contract

An exit contract gives model tuning a fixed objective, resource ceiling, stopping rule, and promotion bar before the first trial starts.

OTA Updates Need a Recovery Budget

A recovery budget turns OTA rollback, rollout limits, health checks, and field support into one measurable product promise for connected fleets.

Make Every Robot Incident Reproducible

Robot telemetry is useful only when a team can reconstruct the failure. Define a replay contract for triggers, context, versions, clocks, and retrieval.

Camera Interfaces Set the Product Boundary

Choose a camera interface by product boundary, not bench convenience. Cable reach, service model, and compute placement all follow that choice.

When AI Should Stop Writing and Start Choosing

Decision models can replace generated prose with bounded choices, but product teams still need calibration, thresholds, and an escape route.

AI Spend Needs an Outcome Ledger

AI costs become governable when teams connect variable model consumption to owners, workflows, outcomes, and explicit product actions.

Self-Improving AI Needs a Holdout Set

Continuous AI optimization can overfit visible failures. A protected holdout set helps product teams prove that each agent change generalizes.

Persistent AI Needs a Shift Handoff

Always-on AI agents need visible queues, ownership, and clean handoffs so people can understand what happened and take over without starting again.

Hybrid AI Needs a Placement Policy

Hybrid AI can route work between local and cloud models. Product teams need visible placement rules for cost, capability, privacy, and recovery.

Generative UI Needs an Escape Hatch

Generative interfaces can make AI answers useful faster, but product teams still need stable state, visible assumptions, and a clean route back to conversation.

Vertical SaaS: The Workflow Is the Training Asset

Vertical SaaS products contain more than data. Their workflows, exceptions, rubrics, and test environments can become valuable AI training assets.

AI Recommendations: The Work Starts After the Answer

AI recommendations create value only when teams can review, execute, verify, and reverse the proposed change without rebuilding its context.

Platform Strategy: Count the Handoffs You Remove

AI platform strategy creates value when integration removes workflow handoffs, preserves context, and reduces the glue customers must maintain.

API Standardization Needs a Next-Market Receipt

API standardization earns its keep when the next market launches without another integration project. Measure reuse by engineering work avoided.

Global IoT Connectivity: Keep the Country Outside the Box

Global IoT products get expensive when country-specific connectivity is baked into hardware. Keep carrier and provisioning choices replaceable after shipment.

Data Freshness Is a Product Feature You Can Price

Data freshness changes which customer decisions a dataset can support. Price update cadence against the decision window, not a generic race to real time.

SDK Product Strategy: Build a Paved Road With Exits

A good SDK shortens the path to a valid business flow without trapping developers. Ship the common implementation, but preserve the API escape hatch.

When Hosting Location Becomes a Product Feature

Customer-hosted software changes product scope. Treat data location, control boundaries, upgrades, and support economics as discovery inputs.

When Satellite Manufacturing Becomes Product Strategy

Satellite manufacturing changes product strategy when added capacity improves replenishment, resilience, or regional control customers can actually use.

FedRAMP Is a Product Roadmap, Not a Compliance Badge

Regulated SaaS needs two roadmaps: feature readiness and market readiness. FedRAMP makes buying dependencies visible before a federal launch.

Product Adjacency: Price the Missing Seam

Adjacent products win when shared data removes synchronization work. Mercury Books shows why teams should price the missing seam before copying features.

Feature Flag Lifecycle Needs an Exit Criterion

Feature flags need an exit criterion. Tie each flag to a product decision, live rollout state, an owner, and a defined retirement event.

Data Deletion Is a Product State Machine

Data deletion works better as a reversible state machine: use policy and context to find candidates, quarantine first, and make deletion the last step.

Enterprise AR Has to Beat the Phone, Not the Headset

Enterprise AR earns adoption by removing motions from an existing phone workflow, not by winning a hardware spec comparison against another headset.

Synthetic Data Is Only as Good as Its Joins

Synthetic data becomes useful test infrastructure when relationships, constraints, and failure modes survive across the database, not just individual rows.

Vertical SaaS Should Map Handoffs Before Features

Vertical SaaS earns its industry fit by removing costly handoffs between existing systems, not merely by adding industry vocabulary to another UI.

API-First Products Should Survive Without Their UI

API-first products let customers choose where workflows live. Full API coverage turns the vendor UI into one client instead of the only front door.

Cyber Resilience Act Reporting Is a Product Workflow

Cyber Resilience Act reporting puts security evidence on a clock. Product teams need traceable incident data before the 24-hour window starts.

Endpoint Management Should Show the Blast Radius

Endpoint management gets safer when high-impact controls expose predicted scope, rollout boundaries, and rollback before an administrator commits.

An Acquisition Roadmap Should Earn Convergence

Product acquisitions should preserve working workflows, connect useful capabilities, and converge only when customers benefit enough to switch.

Wireless Network Validation Should Close the Design Loop

Wireless network validation is more useful when field measurements return to the design model, turning predicted performance into a testable product contract.

Outcome-Based Pricing Needs a Baseline You Can Defend

Outcome-based pricing aligns vendor and customer economics only when both sides can reproduce the baseline, attribution rules, and resulting invoice.

A Custom Silicon Roadmap Needs Checkpoints

Custom silicon trades flexibility for optimization. Multi-generation deals need checkpoints before today's workload assumptions harden into tomorrow's chips.

Developer Onboarding Should Manufacture First Success

Developer onboarding improves when the product supplies missing test dependencies, letting customers reach useful evidence before real data or hardware arrives.

Earth Observation: Revisit Rate Can Be the Product

Earth observation products compete on resolution, but revisit and delivery latency can matter more when customers need to know what changed quickly.

Physical AI Needs an Escalation Contract

Physical AI products need explicit escalation rules. A sensor event becomes a product decision when software decides how long to wait before acting.

Product Defaults Are Product Decisions

Product defaults quietly spend user time. Watch what experienced customers change immediately, then decide whether the baseline is serving the right user.

WebMCP Turns Your Website Into an Agent Interface

WebMCP adds a machine-readable interface beside the human UI. Treat agent actions as product contracts built around intent, permissions, and side effects.

Product Tiers Work Better When Constraints Draw the Line

Product tiers work better when real constraints define the boundary. Before adding another SKU or plan, identify what actually requires a different product.

Data Products Break When Meaning Changes

Data products need compatibility promises beyond schema. A pipeline can stay green while changed field meaning quietly breaks downstream decisions.

Build vs. Buy: Price the Product Freedom You Lose

Build-vs-buy decisions should price more than engineering cost. A supplier becomes strategic when its constraints start shaping what your product can become.

Customer Discovery Needs a Decision Before an Interview

Customer discovery works better when research starts with a decision. Define what evidence could change the roadmap before scheduling interviews.

Developer Platforms Should Hide Their Internal Architecture

Developer platforms improve when APIs expose durable capabilities without forcing customers to learn the internal architecture behind them.

Enterprise Software Can Scale Without Feeling Heavy

Enterprise software can add security, administration, and scale without burdening every user. Separate enterprise controls from the daily workflow.

API Pricing: Your Billing Unit Shapes the Product

API pricing shapes more than margin. Billing units can change scheduling, caching, quotas, customer pricing, and the architecture behind the product.

Satellite Imagery: Hide the Machinery, Keep the Receipt

Satellite imagery is getting easier to query. The product challenge is hiding geospatial complexity without hiding the evidence customers need to trust.

IoT Smart Modules Turn Component Choice Into Product Strategy

IoT smart modules can cut integration work while concentrating OS, supplier, certification, and support dependencies. Treat module choice as product strategy.

API Deprecation: Who Owns the Customer Migration?

API deprecation succeeds when customers actually migrate. Treat adoption, compatibility, testing, support, and shutdown readiness as product work.

AI Agent Memory: Should It Remember Everything?

AI agent memory can improve continuity while making bad information persistent. Product teams need rules for what gets stored, corrected, expired, and forgotten.

Humanoid Robot ROI: Can It Earn Its Keep?

Humanoid robot ROI depends on useful work, intervention, recovery, utilization, and cost per task. A pilot should prove the economics, not the demo.

AI Agent Evals: Your Test Passed. Production Found the Bug.

AI agent evals are only useful if production failures flow back into the test set. A passing score should start a learning loop, not end one.

AI Agent Permissions: How Much Authority Is Too Much?

AI agent permissions should expand with evidence, reversibility, and blast radius. Capability alone is not a reason to grant more authority.

Product KPIs: If the Number Moves, What Changes?

Product KPIs should narrow a decision or action when they move. If nobody changes what they do, the metric may be reporting rather than a KPI.

Product Roadmaps: Plan, Promise, or Portfolio of Bets?

Product roadmaps work better when they distinguish commitments from uncertain bets and show what evidence could change the plan.

Operational Metrics: Your Number Moved. Who Acts Next?

Operational metrics need an owner, a meaningful threshold, and an obvious first action. Otherwise a moving number is only reporting.

MVP Strategy: Are You Learning or Just Shipping Features?

MVP strategy should reduce the riskiest uncertainty, not build a miniature final product. Scope the first version around what you need to learn.

AI Prototypes Usually Fail at the Workflow Boundary

The model is only one component. Most of the product work lives in context, permissions, handoffs, review and recovery.

Build Dashboards Around Exceptions, Not Averages

Operational dashboards are most useful when they make the few abnormal things easier to find than the many normal ones.