Skip to content

01 / RPD OS

From a design idea to an Etsy listing.

Product creation, photo and video mockups, listing preparation and human review in one business workflow.

Active development

My role

Founder, workflow design, integrations and product review

Technology

PythonFastAPIPydanticAITemporalSQLiteDuckDBEtsy APIPrintify API

The problem

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.

Ruffles & Pixie Dust on Etsy

Lifetime Etsy sales
6,489
Global sales ranking
Top 1.8%

Source: eRank dashboard, November 11, 2026. Ranking is based on lifetime sales volume among active Etsy shops.

How I approached it

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.

Decisions that matter.

01

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.

02

Read back an uncertain result

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.

03

Keep checking after release

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.

The implementation

kernel/approvals.py

Bind permission to the exact reviewed actionPython
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.

Provider reconciliation

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

An ambiguous response is still unresolvedPython
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.

Inspect the regression test

tests/test_printify_publish_reconciliation.py

Exercise the uncertain, locked and settled statesPython
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").passed

A regression test with a local provider snapshot. It tests reconciliation logic without publishing a product.

What I check

  • A changed proposal invalidates its approval.
  • Expired approvals cannot authorize a later action.
  • An unsettled provider response stays unresolved.
  • Listing reviews preserve missing metrics as unknown.

The result

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.

See the finished product photos and videos