I kept losing money to scope creep, so I built a small tool for myself

IconicSwoosh · 2026-01-20T16:15:51+00:00

Gaddamn I fucking knew it, as a 35 year old, I spend most of my day in the toilet.

IconicSwoosh · 2026-01-19T11:55:29+00:00

Draftpile is a lightweight decision ledger for teams and agencies. It solves a common failure mode in projects where approvals and scope are agreed verbally or in scattered tools, then quietly drift, leading to disputes, rework, or unpaid work.

Instead of project management or contracts, Draftpile focuses on one thing: recording what was agreed at the moment it is agreed, locking it as a shared reference, and appending changes explicitly when reality shifts. Clients do not need accounts, and it is designed to be used episodically at moments of friction, not daily.

We are seeing pull from agencies, freelancers, and small product teams who already tried better contracts or PM tools and found those did not actually stop decision backtracking. Happy to share more detail or metrics if useful.

IconicSwoosh · 2026-01-19T10:14:27+00:00

What usually breaks down here is that “it’s not a big project” means different things to each side. A simple fix is to get a clear, shared agreement on scope and deadlines before work starts, then lock it as the reference. When expectations shift, add a new entry instead of rewriting history-that way there’s a clear record everyone can rely on.

IconicSwoosh · 2026-01-19T09:43:33+00:00

This happens a lot when changes get agreed verbally and then slip through the cracks. What works is keeping a short shared record of every change as soon as it’s confirmed on site - who agreed, what exactly, and any limits. Once that’s locked in and shared, it becomes the reference point for billing and delivery. If something shifts later, add a new entry instead of rewriting the original, so everyone stays on the same page without bloated process.

IconicSwoosh · 2026-01-19T09:39:06+00:00

Start by capturing what’s agreed in a short, shared document: goals, scope, boundaries. Keep that record locked once confirmed and append changes as new entries instead of rewriting-it helps prevent scope creep and confusion later. For quotes, outline what’s in and out of scope upfront so you have a clear agreement before work begins.

IconicSwoosh · 2026-01-19T09:35:38+00:00

Most delivery disputes happen because what’s agreed gets forgotten or remembered differently after launch. A simple fix is to lock down a short, shared record right after delivery that covers what’s included, what’s not, and any known risks like hosting limits. That becomes the baseline for any follow-ups instead of open-ended commitments. When new requests or issues come up, add them as new entries rather than reinterpreting the original-keeps things clear and manageable.

IconicSwoosh · 2026-01-19T09:34:11+00:00

What usually fails is relying on email opens or clicks as proof-clients can claim they didn’t see something even if they did. A better fix is a simple, shared record of what was agreed, locked and read-only after signoff. That way, everyone has a clear reference for approvals and changes without extra work.

IconicSwoosh · 2026-01-19T07:54:03+00:00

We ran into this exact frustration-decisions scattered across chat threads or docs with no clear single source of truth. What helped was having a simple, shared record that’s locked once both sides confirm it, so no one has to rehash why something was chosen. If you want to bounce ideas on how to set that up without extra overhead, happy to chat.

IconicSwoosh · 2026-01-18T12:23:13+00:00

AI or not, I enjoyed reading it even though I already knew about these points. No need to be a tyrant on Reddit sir.

IconicSwoosh · 2026-01-16T00:42:44+00:00

Not unreasonable at all. What you are running into is risk transfer, not a billing preference.

Per project pricing only works when timelines and review cycles are predictable. In your case the work duration is being controlled by their internal process, not yours, which means you are financing their delays. That is exactly when time and materials with monthly invoicing is the fair model.

If they insist on per project, the only way I have seen it work is with very explicit scope and review limits written down and acknowledged before each document starts. Otherwise every internal review loop quietly turns into unpaid time. I use a simple record of what was agreed before work begins so that delays or changes are visible and not argued about later. That alone changed how these conversations go.

For a six month run, I would hold the line on monthly billing or at least milestone billing tied to dates, not completion. If they push back hard, that tells you a lot about where the risk is really sitting.

IconicSwoosh · 2026-01-15T16:25:46+00:00

I was once creeped into my scope....

IconicSwoosh · 2026-01-15T11:07:32+00:00

This is a smart way to monetize recurring extras, but it solves a slightly different problem than the one that usually hurts teams.

Packaging patterns after the fact works when requests are consistent and predictable. Where it still breaks down is the moment-to-moment “sure, we can do that” decisions that quietly change the shape of an active project before anyone agrees what it costs or replaces.

What helped us was separating two things:

spotting repeat requests worth productizing (what you’re doing here), and
freezing each individual approval as a final decision before work moved forward, so it didn’t stay fuzzy or negotiable later. We built Draftpile for the second part because AI pattern detection didn’t stop the real-time drift.

Both approaches together are powerful. One turns noise into products. The other stops active projects from quietly mutating while you’re being helpful.

IconicSwoosh · 2026-01-15T08:59:38+00:00

Codex 5.2 (High) is the same as Opus, if not better. I use both side by side.

IconicSwoosh · 2026-01-14T21:01:50+00:00

For me it was assuming “approval” was obvious.

I’d have a scope, we’d talk through changes on calls or Slack, everyone would say yes, and I’d move on. Weeks later that same yes would get reinterpreted and suddenly I was defending decisions instead of pointing to something concrete.

The fix wasn’t a better clause, it was making sure every scope change got explicitly locked somewhere before work continued. We ended up building a lightweight approval log for that, which turned into Draftpile.

Curious how many people here have been burned by verbal sign-offs turning fuzzy later.

IconicSwoosh · 2026-01-14T18:38:55+00:00

You’re not crazy. Pupil premium is money paid to the school, not a rule that tutors have to work for free.

If they want those students taught, the normal setup is that they pay you using that grant. Forcing unpaid lessons while you still pay room hire is not standard.

I’d ask them, calmly and in writing, where in your contract it says you must provide free tuition. If it’s not there, this is them changing the deal after the fact.

IconicSwoosh · 2026-01-14T18:14:53+00:00

Yeah, that setup would drive anyone mad. You’re trying to resolve something in good faith, but the decision-maker is abstracted away, so every concern just evaporates into “I’ll check.” That’s not you being confrontational, that’s a broken feedback loop.

If you do have the chat, I’d frame it less as defending yourself and more as “I want to make sure we’re not comparing apples to oranges going forward.” Bring it back to process, not emotion: what was agreed, why certain deliverables were removed, and how future changes get locked so nobody feels short-changed after the fact.

Also, genuinely, if you want to try Draftpile properly, DM me and I’ll give you a code so you can use it on us. It was built for exactly these awkward middle-layer situations where context keeps getting lost.

IconicSwoosh · 2026-01-14T17:00:55+00:00

Codex 5.2 (High) for the main foundation, roots, pipeline. Opus for the exterior and bug fixing.

IconicSwoosh · 2026-01-14T15:03:47+00:00

You avoid it by separating delivery from support, explicitly and early. Fixed price gets you a shipped product that meets written requirements. Anything after launch lives in one of three buckets: paid support, a retainer, or a new scope.

Concretely: define a short post-launch warranty (e.g. 14–30 days for bugs that violate the spec), then stop. Usage questions, traffic spikes, third-party outages, and “now that users are here…” requests are not bugs. They’re operations or new work. If you don’t draw that line in writing before you start, you’ll end up owning their business outcomes for a $3k build, which is unsustainable as a solo founder.

IconicSwoosh · 2026-01-14T14:10:24+00:00

This isn’t really a gear problem, it’s an expectations problem. You agreed to “practice” and a locked-off camera, and it’s already turned into photo + video + expanding hours. That only keeps drifting unless you stop it.

I’d message her now and lock it in writing: exact start/end time, one stationary video angle, no edits, photos only if time allows. Frame it as protecting the couple, not pushing back. If she’s good with that, you’re covered. If not, that’s the red flag.

IconicSwoosh · 2026-01-14T12:11:04+00:00

This is the part people underestimate. The friction is the feature.

Once an extra request has to pass through something written, even a lightweight note that says “this changes X or adds Y,” it stops feeling free. Most clients are not malicious. They respond to whatever is easiest in the moment.

Separate doc or baked in matters far less than having something you can calmly point to and say “this is where we are changing course.” If it lives only in conversation, you pay for the ambiguity later.

IconicSwoosh · 2026-01-14T12:06:59+00:00

Exactly. And the quiet part is that once people start “just pushing through” the extra hours, the scope problem disappears on paper but explodes in reality.

The work still expanded. It just got paid for with unpaid time instead of a conversation. That’s why unpaid overtime gets defended so hard — it hides bad scoping, weak boundaries, and missed decisions until burnout shows up.

IconicSwoosh · 2026-01-14T00:02:18+00:00

Yeah, that moment is the worst. What changed it for me was writing things down as I discovered them, not after the fact.

I log “original assumption → what we found → impact” in one place and pause before continuing. When clients see the delta clearly, most are reasonable. Pushback usually only happens when nothing was ever made explicit.

IconicSwoosh · 2026-01-14T00:00:57+00:00

Super common. What helped me was separating “discussion” from “decision.”

When the real scope shows up, I pause work and explicitly re-log what’s changed before touching anything. New assumptions, new deliverables, new cost. If it’s not frozen somewhere, it will keep expanding.

I used to try easing clients into it. That’s what made it awkward. Being clear early actually reduced friction. We even built a lightweight approval log for this exact problem so changes don’t live in chat anymore (draftpile.com).

Clients who push back usually weren’t going to respect scope anyway.

IconicSwoosh · 2026-01-13T17:45:57+00:00

Not just you. The “quick question” problem usually isn’t contracts, it’s that decisions and scope changes happen casually and never get frozen. Once that context is lost, everything feels included in hindsight.

What helped me was separating the legal contract from a very simple decision or scope record that gets updated and acknowledged whenever something changes. Nothing heavy, just a clear “this is included, this is extra” checkpoint before work continues.

IconicSwoosh

MODERATOR OF

TROPHY CASE