(or: How I’m Learning to Step Back So We Can Move Forward)
Here’s a pattern I’ve been contributing to more than I’d like to admit:
Someone on the team proposes a new internal tool. There’s a clear need. There’s momentum. Conversations start about how we’ll build it… what tools we’ll use… where it’ll live… whether it might become client-facing someday.
It hasn’t been built yet, but we’re already architecting the scaffolding.
And that’s usually when I step in.
Not with a thumbs-up. Not with funding. But with questions. The kind that start with, “What if we didn’t build this?”
It’s not fun. It’s not fair. And it’s not how I want to lead.
By that point, people are invested. They’ve done the thinking. They’ve shared the idea. They’ve taken a risk. And now I’m asking them to scale it back—or stop entirely.
This is me taking responsibility for that pattern.
So I did the only thing I know to do in moments like this: I wrote it down.
We now have a model. Internally, we call it The Internal Tooling Maturity Ladder.
🪜 The Ladder (in Plain English)
Level 0 – One-off Manual Script
Something one person runs on their own machine to save time or reduce repetitive work.
Maybe it lives in an unsaved file or as a task in Alfred or Automator.
It’s not elegant—but it works.
You run it manually. You copy-paste the result. You feel smug for five minutes.
No repo. No expectations. No long-term promises.
Example: A quick Ruby or Bash script that tallies something from an API and drops it into Slack.
Level 1 – Shared Manual Script
You cleaned it up. You wrote a little README. You dropped it in a shared Gist or Google Drive.
It’s still manually triggered, but now others can use it too—if they read the instructions.
It’s still lightweight. Still safe.
And it’s often where great tools should stay.
Example: A command-line tool that a few team members can run locally, maybe to generate a report or fetch usage stats.
Level 2 – Scheduled Automation
Now we’re automating things.
It runs on a schedule—maybe through Zapier, a GitHub Action, or a scheduled Rake task.
No UI. No buttons. Just automated updates that go where we already spend time.
Slack. Google Sheets. Email.
These tools hum quietly in the background, doing one job well.
Example: A script that posts weekly project stats to a Slack channel every Monday morning.
Level 3 – Lightweight Internal Service
Now we’re getting fancy.
This has a small UI. A form. A dashboard. Maybe some configuration options.
It needs hosting. Credentials. Some thought about security.
It’s still simple enough that one person can manage it—but now it’s a thing.
And it needs some care.
Example: A mini app that lets the team search across client project docs or surface stale Jira tickets.
Level 4 – Fully Hosted Internal Product
This is a real web app.
It’s deployed. It has a frontend and a backend. It has users. Sessions. Maybe even tests (hopefully).
It needs to be maintained. Updated. Monitored.
It might solve a meaningful problem—but it’s not free.
This is the top of the ladder for a reason.
Example: A polished internal dashboard that’s become a critical part of day-to-day operations.
Start Lower
This isn’t a blueprint. It’s a conversation starter.
The higher you go, the more you commit—time, infrastructure, expectations.
So we’re learning to start lower on the ladder.
To earn our way up.
To see if people care before we care too much.
Why It Matters
Every internal tool is a promise.
To support it. To upgrade it. To explain it to the next person who inherits it.
And sometimes… the smallest version of the tool is all we need.
A Slack post.
A spreadsheet.
A script that helps one person do their job 10% faster.
Not everything needs a UI.
Not everything needs a repo.
And not everything needs me to be the one who calls time on the project two weeks in.
This post isn’t about our internal model. Not really.
It’s about building fewer things that trap us.
And creating more space to experiment without regret.
If you’ve found yourself playing the role of reluctant gatekeeper… you’re not alone.
This ladder is helping me find a better way.
One rung at a time.
