Approval belongs to a specific change
An approval records the proposal hash, target, operation and expiry. Changing the proposed action requires a fresh review. A previous yes cannot quietly become permission for something else.
01 / RPD OS
Product creation, photo and video mockups, listing preparation and human review in one business workflow.
Active developmentFounder, workflow design, integrations and product review
I run Ruffles & Pixie Dust, a custom product business. A finished listing needs much more than a design: product options, useful images, accurate copy, pricing and a clear path to fulfilment. Doing each step separately creates a lot of repeated work.
Source: eRank dashboard, November 11, 2026. Ranking is based on lifetime sales volume among active Etsy shops.
I am building RPD OS to connect those steps. Typed tasks and provider adapters carry the work between stages. Review stays attached to the exact proposed change, and saved workflow state gives long running jobs a place to resume.
Follow the workflow. Select a stage to see its purpose.
Plan. Start with the product, customer, market evidence and cost assumptions.
An approval records the proposal hash, target, operation and expiry. Changing the proposed action requires a fresh review. A previous yes cannot quietly become permission for something else.
A provider can accept a request before the finished result is visible. Publication reconciliation checks the external mapping and provider lock state before treating the operation as settled.
The listing monitor checks for issues such as a missing title, duplicate tags and zero stock. It keeps unavailable performance data separate from an actual zero.
kernel/approvals.py
def assert_valid_for(self, proposal: ProposedAction, at: str | None = None) -> None:
checks = {
"proposal_id": self.proposal_id == proposal.proposal_id,
"proposal_hash": self.proposal_hash == proposal.proposal_hash,
"capability_version": self.capability_version == proposal.capability_version,
"targets": self.targets == proposal.targets,
"channel": self.channel == proposal.channel,
"operation": self.operation == proposal.operation,
"baseline": self.baseline_digest == (proposal.baseline.digest if proposal.baseline else None),
}
failed = [name for name, passed in checks.items() if not passed]
if failed:
raise ApprovalInvalid(f"approval does not bind exact proposal fields: {', '.join(failed)}")
if proposal.is_expired(at) or parse_utc(at or utc_now()) > parse_utc(self.expires_at):
raise ApprovalInvalid("approval or proposal has expired")The approval validation method from RPD OS. The proposal hash, scope, baseline and expiry must agree before the action can continue.
An integration needs a decision for the uncertain case. This adapter checks what actually happened before the workflow treats a publication as complete.
adapters/printify_v1.py
def reconcile(self, proposal: ProposedAction, attempt_id: str) -> VerificationResult:
if proposal.operation == "update_private_copy":
return self._private_copy_verify(proposal, attempt_id)
if proposal.operation == "republish_metadata":
return self._metadata_verify(proposal, attempt_id)
if proposal.operation == "update_metadata":
return self._metadata_update_verify(proposal, attempt_id)
observed = self.snapshot(proposal.operation, proposal.targets)
applied = product_effect_matches(observed, proposal.expected_effect)
unchanged = subset_matches(observed, proposal.before)
if proposal.operation == "publish_product":
external = observed.get("external") or {}
applied = applied and bool(str(external.get("id") or "")) and observed.get("is_locked") is False
# An accepted asynchronous publication may still show its old state.
# That observation cannot establish that retrying its POST is safe.
unchanged = False
return VerificationResult(
proposal_id=proposal.proposal_id,
attempt_id=attempt_id,
authority="printify",
passed=applied,
checks={"effect_applied": applied, "before_state_unchanged": unchanged},
observed=observed,
expected=proposal.expected_effect,
reason="write applied" if applied else "publication outcome remains unconfirmed" if proposal.operation == "publish_product" else "write not applied" if unchanged else "remote state is divergent",
)The adapter reads back provider state. Publication needs an external listing ID and a released provider lock. Seeing the old state does not establish that another publish request is safe.
tests/test_printify_publish_reconciliation.py
def test_async_publication_requires_settled_mapping_and_unchanged_is_not_proof_of_absence():
adapter = PrintifyV1Adapter()
state = {"id": "fixture", "external": {}, "is_locked": False}
adapter.snapshot = lambda *args: state
proposal = SimpleNamespace(operation="publish_product", targets={}, expected_effect={"id": "fixture"},
before=dict(state), proposal_id="fixture-proposal")
uncertain = adapter.reconcile(proposal, "fixture-attempt")
assert not uncertain.passed and not uncertain.checks["before_state_unchanged"]
state.update(external={"id": "777"}, is_locked=True)
assert not adapter.reconcile(proposal, "fixture-attempt").passed
state["is_locked"] = False
assert adapter.reconcile(proposal, "fixture-attempt").passedA regression test with a local provider snapshot. It tests reconciliation logic without publishing a product.
The commerce work includes published Etsy listings with photo and video mockups. When listing errors reached my shop, I added checks before posting and recurring reviews of the shop. That experience continues to shape the system.