What we built to use ourselves first.

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.

Sincron productsAll live
  • Whisper DictatorWindows app
  • Convert File FastAPI
  • Sincron Screen ToolsWindows app
  • Secretaria24hWhatsApp service
The tools

Each page here explains why the tool exists.

They’re narrow in scope on purpose, and sold on their own websites. The story from the people who built them is here.

Windows app

Sincron Screen Tools

Translate, understand and annotate what’s on your screen, without copying anything anywhere else

Why this exists

Why an automation consultancy also builds products.

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.

What operating teaches

Shipping software is one thing. Keeping it running is another.

Three lessons that could only come from the inside, and that changed how we run client projects.

01 · Support

The real cost shows up after delivery

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.

02 · Real use

People almost never use what we planned for

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.

03 · Limits

Saying what it doesn’t do shortens the cycle

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.

How it comes back

What we learn running our own tools makes its way back to the client’s table.

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.

Honesty first

What these tools are not.

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.

Each one solves just one problem.

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.