Every time I finish a job, I ask what part of it could become a template, a checklist, or an automation for next time. We stay small by starting from zero on every project. The ones that grow turn each job into a reusable system, so the next one starts faster than the last.
I used to start every project from scratch and then wonder why I was always tired. Every new client, every new deliverable, every new campaign began with a blank page, and I treated that blank page like a fresh start instead of what it actually was: a sign that I hadn't kept anything from the last time. I was solving the same problems over and over, just with different names attached to them, and calling it hard work.
Why I built this in the first place
This is hack 30, the last of the original thirty in this series, and it's the one that ties the rest of them together. Almost every hack before this one, the templates, the checklists, the automations, the "write the SOP the second time" habit, all come back to the same underlying shift: we stay small by starting from zero on every project. The businesses that grow are the ones that turn each finished job into a reusable system instead of a one-time effort.
That's not a productivity trick. It's the actual difference between a business that scales and one that just works harder. If every project requires the same amount of original thinking as the last one, you have a job, not a system. The moment a finished project leaves something behind that makes the next one easier, you've started building an asset instead of just logging hours.
The end-of-project question
The actual habit is simple to describe and easy to skip. When I finish a job, before I move on to whatever is next, I ask myself one question: what part of this could be a template, a checklist, or an automation for next time? Not "was this project a success." Not "what would I do differently." Specifically: what did I just do that I am going to do again, in some form, for someone else?
Most projects have at least one honest answer. It might be the intake questions I always end up asking a new client in the first call. It might be the sequence of steps I follow every time I launch a page, in the same order, because I learned the hard way what happens when I skip one. It might be a piece of the work that has zero judgment involved, the kind of repetitive step a tool could just run for me. The question isn't whether a system exists in the work you just did. It's whether you stopped long enough to notice it.
How to spot what's actually worth systemizing
Not everything from a finished project deserves to become a system. Some parts really were one-off, specific to that client or that moment, and turning them into a template would just be extra overhead for no future benefit. I use two signals to sort the two apart.
Anything you did more than once
If a step showed up twice in the same project, or if it's a step I recognize from a past project, that's the clearest signal there is. Repetition is the whole argument for a system. A step that happens once doesn't need a template. A step that happens every time is wasting effort every time it gets rebuilt from scratch.
Anything that required remembering a lot of small details
The second signal is subtler but just as reliable. If a step depended on me remembering a list of small things, the right order, the setting I always forget to change, the field I always have to double check, that's a step that will eventually get missed. Details you have to hold in your head are exactly the details a checklist exists to hold instead.
If I can picture doing this exact step again for a different client next month, it's worth capturing. If I genuinely can't, I let it go. Not every part of a project is reusable, and forcing a system out of something that was truly one-off just adds clutter.
Template, checklist, or automation: they're not the same thing
I used to lump all of this under "documentation," and that was part of the problem. The three forms a system can take are genuinely different, and knowing which one a given step needs is what makes the system actually get used later instead of sitting in a folder.
A template is a starting document. It's something you duplicate and fill in, instead of opening a blank file and building the structure again. A proposal outline, a project brief, an email sequence, a slide deck skeleton. The value of a template isn't that it saves typing. It's that it removes the decision of "what goes where," which is usually the slowest part of starting anything.
A checklist is a sequence to follow. It's not a document you fill in, it's a list you work through in order, so nothing gets skipped and nothing depends on your memory that day. Launch steps, onboarding steps, a pre-send review. A checklist earns its place the first time it catches something you would have otherwise missed.
An automation is something that runs without you. It's the step that doesn't need your judgment at all, just execution, so a tool or workflow does it instead of you doing it by hand every time. A recurring report, a follow-up email, a file that renames and files itself. Automations are the highest-leverage of the three, but only for steps that genuinely require zero decision-making. Force a step that still needs your judgment into an automation, and you'll spend more time fixing what it got wrong than you saved.
A template saves you from a blank page. A checklist saves you from your memory. An automation saves you from doing the step at all.
Capture it right after you finish, not later
The habit only works if you do it at the right moment, and the right moment is immediately after you close out the project, not next week when you have "more time." I've tried waiting, and it never works the way I hope it will. The details that make a template actually useful, the edge case that almost tripped you up, the order steps had to happen in, the line a client always asks about, are sharp in your head for a day or two and then they're gone. A week later, rebuilding that context takes almost as long as it took to do the work the first time, which defeats the entire purpose.
So the actual practice is small: right after I wrap a project, before I open the next one, I spend a few minutes writing down the one thing from the answer to that end-of-project question. Not a polished document. Just enough that future me, or whoever else touches this kind of work next, isn't starting from nothing. The system gets refined later, the second or third time it's used. The first version just has to exist.
The end-of-project habit, in order
The throughline across all thirty hacks
This is the last of the original thirty hacks, and it's also the one underneath most of the others. The template you build from writing the SOP the second time, the checklist behind the two-minute rule, the automation that reads your newsletters or replies to your emails, every one of them started as a project that got finished once and then turned into something reusable. Systems compound. A template used ten times has saved you nine blank pages. A checklist that catches one mistake a month has quietly protected a client relationship you never even had to think about. None of it looks dramatic in the moment. It just means the fortieth project starts faster than the fourth one did.
That's really the whole idea behind this series. I help small teams do big things, and most of what that looks like isn't a clever new hack, it's making sure the useful parts of yesterday's work don't have to be reinvented tomorrow.
Key takeaways
- At the end of every project, ask what part of it could become a template, a checklist, or an automation next time.
- Look for two signals to decide what's worth capturing: anything you did more than once, and anything that required remembering a lot of small details.
- A template is a starting document, a checklist is a sequence to follow, and an automation is something that runs without you. They solve different problems.
- Capture the system right after finishing, while the details are still fresh. Waiting even a week means rebuilding context you already had.
- Businesses stay small by starting from zero on every project. The ones that grow turn each finished job into a system for the next one.
This series didn't stop at thirty. I keep finding and sharing new hacks, like Hack 31 on giving an AI tool read-only access to read your newsletters for you, all linked from the full hacks index.
Frequently Asked Questions
A template is a starting document, something you duplicate and fill in instead of building from a blank page. A checklist is a sequence to follow, the exact order of steps so nothing gets skipped and nothing depends on memory. An automation is something that runs without you, a workflow or tool that does the repeatable part on its own once it is set up. Most finished projects contain the raw material for at least one of the three.
Look for two signals. The first is anything you did more than once, inside this project or across past ones. The second is anything that required you to remember a lot of small details, the kind of thing you would forget by the next time you needed it. If a step meets either signal, it is worth capturing.
Right after finishing, before you move to the next thing. The details that make a template or checklist actually useful, the edge cases, the order that mattered, the step you almost forgot, are freshest in the minutes after you close out a project. Waiting even a few days means rebuilding that context from scratch, which defeats the purpose.
No, it works at any size, and it matters most for small teams. A solo operator or a small business has the least spare capacity to redo work, so the templates, checklists, and automations built from one finished job are what let the next job start faster instead of from zero.
