Estimate → approve → build
Markup is a headless dev shop behind a script tag. Clients drop pins where something's wrong; the pipeline estimates, builds, and stages the fix — you click once and staging rolls live, with rolling backups the whole way.
One pin, end to end
Your client clicks the exact spot on their own site. A snapshot freezes the page — the pin can never drift.
Invoice: carry handling & processing fees onto issued invoices
staging → production
Built for Shopify
Theme work is where Markup shines. Pin the thing on your live storefront — a section that breaks on mobile, a badge in the wrong place, a landing page you wish existed — approve the estimate, and the machine does the work on a copy of your theme. You get a preview link; publishing is one click; the theme you're running today stays untouched until you say go, and it's your instant rollback after.
One app-embed toggle in your theme editor puts the pin widget on your store. No code edits, no developer needed to get started.
You and your team drop pins on the live store. Every pin gets an estimate in dollars — nothing runs until you approve it.
Every fix lands on an unpublished duplicate of your theme with a shareable preview. Like it? Publish. Don't? It never touched your store.
On the Shopify track, tokens are included in the subscription — no API keys, no meters, no surprise usage bills. Theme jobs are bounded work, so the estimate you approve is the whole price.
The proof moment
The snapshot taken when the pin dropped is the “before.” When the work lands, Markup pairs it with the “after” — so acceptance takes seconds, not another meeting.
Try it — drag the handle.
The headless dev shop
Markup isn't another inbox of feedback. Wire it to your repo and CI — or hire us to — and the whole path from “this is wrong” to “fixed in production” runs itself. And you're backed both ways: rolling backups behind every deploy, and our engineers behind you whenever you want humans on the work.
One script tag on any site — production, staging, a prototype. Clients pin what they want changed; no accounts, no new tool to learn.
Connect GitHub and your pipeline — or have us set it up. Approved pins become branches, pull requests, and green check runs.
You approve the estimate, then approve the go-live. Everything lands on staging first, with rolling backups — rollback is one click.
What's in the box
Everything a studio needs to run visual review with clients — and nothing that requires them to make an account or learn a tool.
A click drops a numbered pin anchored to a snapshot of the page. The live site can change underneath — the pin stays where the feedback was.
Every pin is a conversation with a comment count. Zoom into the exact area, go back and forth, resolve when it's actually done.
Attach an effort estimate to any pin and let the client approve it in place. Scope conversations happen where the work is, not in email.
Reviews move draft → approved → in progress → delivered → accepted. Everyone can see where each request stands at a glance.
The snapshot at pin-time is the before. When you deliver, the client gets a draggable comparison — verification without a meeting.
One <script> tag. The widget mounts in a shadow root, so it can never collide with the host page's styles — yours or your client's.
Built for the agent era
# a new pin appeared — your agent picks it up
GET /api/projects/:id/pins?status=open
Authorization: Bearer mk_agent_…
# it scopes the work, confidence-gated
POST /api/pins/:pin/estimate
{ "points": 2, "confidence": 0.93 }
# ships the fix, attaches the proof
POST /api/pins/:pin/comments
{ "body": "Delivered — before/after attached",
"deliverable": true }For dev teams & day zero
Run a Shopify store? That's the fast lane — connect it and you're done. For everyone else: choose an open-source starter, or point us at a repo you already have. Either way it lands in your own GitHub org with the widget installed, and from there you don't write code: you drop pins on the thing you want it to become.
Catalog, cart, checkout — pin your way to a shop.
Landing pages, blog, forms. Launch this week.
Auth, billing, admin — the boring parts pre-built.
Structured docs with search, versioned.
Your repo, your code, permissive licenses — the pipeline is the service, not a hostage. Self-serve, you connect your own hosting and CI/CD (guides included); on Concierge we set all of it up for you. Works with your AI assistant too: point it at Markup and let it queue the pins.
Install
Works on production sites, staging, prototypes — anything that runs in a browser. Shadow-DOM isolation means it can't break the page it's reviewing.
<script src="https://markup.rivlet.io/embed.js" data-key="your-project-key" defer></script>
Pricing
This replaces the retainer agency. On self-serve your own tokens power the work — we just rent you the machine (Shopify stores get tokens included). On Concierge, every job is billed by the estimate you approve. Never by the hour, either way.
Markup is built for organizations that would otherwise keep an agency or a dev team on retainer — the same scope of work, from new features to full redesigns to ongoing maintenance. The difference: the platform is a subscription, and every dollar of development effort is approved by you, per pin, before it's spent.
$0 / mo
Client feedback, organized
$29 / mo
Run client review yourself
$299 / mo · your tokens
Rent the machine
Per delivery — never hourly
Pipeline + our engineers — the agency replacement
The agent never works on spec: every pin gets an estimate, and nothing runs until you approve it. On Pipeline the loop runs on your own LLM API key — your tokens, your budget, your call, with per-run caps. On the Shopify track tokens are included in the subscription, and work happens on an unpublished copy of your theme until you publish. Every run is supervised by a human: on Pipeline that's your team, from the run console; on Concierge it's ours. Early access carries no SLAs. Free projects are one domain per organization.
SSO, SLAs, security review, dedicated senior engineers, and custom terms — for organizations running serious development effort through the pipeline.
Early access
Markup was built inside real client engagements before it had a landing page. We're opening it up team by team.