Whisper Dictator
Speak and the text appears where your cursor is, without the audio leaving your computer
Every tool here started as a bottleneck that hurt our own operations before it became a product. They’re all live, with people using them, us included.
They’re narrow in scope on purpose, and sold on their own websites. The story from the people who built them is here.
Windows appSpeak and the text appears where your cursor is, without the audio leaving your computer
APIThe file goes in one format and comes back in the format your process expects, in the same response
Windows appTranslate, understand and annotate what’s on your screen, without copying anything anywhere else
WhatsApp serviceAnswers and books appointments on WhatsApp at any hour, within the schedule you set
The short answer: we got tired of recommending tools we’d never had to keep running ourselves.
Automating other people’s processes is a job made of choices. On almost every project there comes a point where one step in the flow depends on an off-the-shelf tool, and deciding which one to use falls to us. For a long time we made that call from the outside: reading documentation, testing for a week, trusting the pricing page. The client found out the rest: the limit that only shows up under month-end volume, the support team that takes three days to reply, the price increase that lands on the contract anniversary.
Building our own was how we brought part of that decision in-house. None of the tools above came out of a portfolio meeting. Each one came from a bottleneck that hurt our own operations or a client’s first, and that we couldn’t solve by buying something. When the same problem shows up for the third time at three different companies, it’s no longer an exception, and it becomes worth the cost of building.
The bar for starting is conservative on purpose, and it’s worth stating: only what we use in our own day-to-day becomes a product. It’s an annoying filter, because it throws out good ideas nobody in here would use. But it’s the only one that keeps a project-based firm from turning into a software factory that nobody operates.
Three lessons that could only come from the inside, and that changed how we run client projects.
A client project ends with sign-off; a product never ends. Whoever takes the Friday-night ticket learns fast which decisions generate tickets and which don’t. Today the question “who responds when this fails?” comes in at the start of the project, not at the close, and it changes the design more than any architecture discussion.
Every new screen carries an expectation of how it will be used, and many of those expectations don’t hold. A feature that seemed central gets opened once and abandoned; a detail that almost got cut becomes the reason someone keeps subscribing. Seeing this in our own product made delivering in waves less of a methodology talking point and more of a defense against our own guesswork.
The temptation when you’re selling is to leave the limits implicit. We tried it, and the bill came due as cancellations in the second month, far more expensive than the sale that didn’t happen. Stating early what’s out of scope shrinks the audience and improves everything that comes after. It’s the same reason we tell you straight when a process isn’t worth automating.
Not as a case study in a slide deck. As decision criteria inside the project.
The most useful part is the most boring to explain: we now have firm opinions on maintenance cost. When an automation can be solved three ways, the choice is rarely technical. It’s about who will maintain it eighteen months from now, how often the vendor changes the rules of the game and what happens the day the person who understood it leaves the company. Whoever delivers and walks away doesn’t have to answer that.
It also changed what we’re willing to build from scratch. Having written our own software makes the size of the commitment behind every new tool very clear: documentation, updates, migrations, the day it breaks. That’s why a good share of the recommendations that come out of our projects is not to build: use what already exists, or simply stop doing the step whose purpose nobody can explain.
And there’s a direct effect: sometimes the missing piece in the flow has already been built. When that happens, we say where it comes from and what it costs, and the decision stays with the client. What doesn’t happen is one of our products entering the scope for convenience. The bar is the same one we apply to third-party tools.
A stated limit saves you the trial that wouldn’t make sense, and the conversation that was going to end in frustration.
None of them is our consulting in a box. They’re narrow-scope tools, each built to solve one problem, and sold on their own websites at a subscription price. If your pain is “work gets stuck between two systems and nobody knows exactly where,” no off-the-shelf tool will fix it: that’s process automation work, with a design built around your operations.
Order matters too. Buying a tool before understanding where the time is going is the fastest way to pay a subscription for a problem that wasn’t the real one. When in doubt, the cheap way to start is to measure, and only then decide whether the answer is to buy, build or stop doing it.
If yours is bigger than one tool can solve, the path is a different one, and it starts by finding out where your team’s time is going today.