How We Use Our Own Software

We build data integration and automation software, so it probably won't surprise you to hear that we use it ourselves in our day-to-day processes. What might be more interesting is how we use it, and why we've made the choices we have.

Ouvvi, our automation server, sits at the centre of most of what we do operationally. It handles everything from deploying our applications, to processing helpdesk emails, and tracking renewals. But the use case that's most transferable to other businesses — is how we manage our sales pipeline.

This blog walks through that in detail, touches on a few of our other Ouvvi setups, and offers some thoughts on why building this kind of automation on your own infrastructure, with your own tools, is worth the initial effort.

The case for owning your own automation

Before we get into the specifics, it's worth explaining the philosophy behind why we've built it this way.

There's no shortage of SaaS tools that will manage your sales pipeline, process your renewals, and alert you to cancellations. Some of them are very good. But every tool you add to your stack is also another place your data lives, another set of permissions to manage, another privacy policy to review, and another dependency to maintain.

When you build automation in Ouvvi and Data Sync, the data stays on your infrastructure. You decide what gets stored, where, and for how long. You control who has access. There are no third-party services reading your order data or customer records. If something goes wrong, you can see exactly what happened and why because you built it.

For us, that matters. Our customers trust us with their details, billing information, and licence data. We're not going to route that through a tool we don't control just because it could be slightly more convenient to set up.

The broader point:
If your business handles customer data, and almost every business does, understanding where that data flows matters. Building automation in-house, on your own systems, is one of the most straightforward ways to stay in control of it.

Our sales pipeline: the problem we were solving

Our orders and renewals come through Paddle, our Merchant of Record and payment processor. Before we had any automation in place, keeping on top of new orders, upcoming renewals, and cancellations meant checking manually: watching for emails from Paddle, cross-referencing with our own records, and trying not to miss anything.

We did miss things sometimes. Not often, but enough. A renewal would slip through. A cancellation wouldn't get processed promptly. There was friction between the payment data and our helpdesk system (our in-house CRM), which meant someone had to bridge the gap by hand every time.

We wanted to fix that, but we also wanted to be deliberate about how far we took the automation. That distinction ends up being an important part of the story.

New orders

When a new order is placed, Ouvvi detects a change in the orders table in our database, it uses a SQL trigger watching for the latest record date. That trigger kicks off a Data Sync project that pulls the order details together from several sources: the invoice, the application details, and the licence key itself. All of that gets written into an Ouvvi App, essentially a structured data store, called simego_paddle_orders. From there, Ouvvi sends a HTML report email to our sales address with the full order details, including quick links to the Paddle receipt and our licence transfer page. The record is then marked as sent, using Data Sync, so it isn't included in future emails.

If anything in that chain fails, a failure notification goes to the same sales address so we’re always aware of what’s happening.

How you might use this:
If you process orders through any payment platform that writes to a database, you can use the same pattern: watch for new records, pull and enrich the data you need, deliver it wherever your team works. The output doesn't have to be an email: Ouvvi App data can also be fed directly into a reporting tool like Power BI, giving you a live view of orders, renewals, or whatever else you're tracking. All without that data ever leaving your infrastructure.

Upcoming renewals

The renewals process runs at the start of every business day. Ouvvi queries our licence key database for any keys expiring within the next 30 days and writes those records into a separate Ouvvi App: simego_renewals. From there, the same pattern applies: a report email goes to sales, the records are marked as sent, and a failure notification fires if anything goes wrong.

This gives us a daily, reliable view of which customers are coming up for renewal, without anyone having to go and check. And because we track what's been sent, we don't get duplicate alerts.

How you might use this:
The 30-day rolling window query is a simple but powerful pattern. Any time you need to act on records approaching a threshold, the same approach works: query for what's coming up, write it somewhere useful, and act on it. Think contract end dates, subscription expirations, trial periods, or support ticket SLAs.

Cancellation alerts

When a subscription is cancelled in Paddle, the status on the subscription record changes. Ouvvi watches for that status change and, when it detects one, writes the cancellation details to another Ouvvi App: simego_paddle_subscription_cancelled. The same send-and-mark pattern applies: a report email goes to sales, the record is flagged as sent to prevent duplicates, and a failure alert fires if the process doesn't run. We can then update our CRM to not send any further reminders. This one runs on an hourly trigger rather than daily, because cancelled subscriptions are something we want to know about quickly.

How you might use this:
Status-change detection is one of the most useful patterns in data automation. If you have records in a system where a field changing from one value to another means someone needs to take action, this approach translates directly.

A deliberate choice: keeping humans in the loop

We could automate this process further. It would be technically straightforward to have Ouvvi send renewal reminder emails directly to customers, or push order data straight into our CRM without anyone reviewing it. We've chosen not to do this, and the reason is worth explaining.

Customer names are messy. People enter their name in different formats. Sometimes a first name is actually a company name. Sometimes the contact is a shared inbox and addressing an email to a specific person would be wrong or odd.

If we sent automated renewal emails using that data unchecked, some of them would go out with the wrong salutation. That's a small thing, but it's the kind of small thing that erodes trust. Automation that introduces errors isn't better than doing it manually, it's just faster at making mistakes.

So, our pipeline delivers clean, complete data to our sales team with everything they need to act quickly: order details, licence information, direct links to the relevant pages. The human step is reviewing the name, deciding on the message, and sending. That takes a few seconds per record, and it means the customer gets something that actually makes sense and is a bit more personal.

The automation removes the risk of missing something. The human step removes the risk of sending something wrong.

What else do we run through Ouvvi?

The sales pipeline is the most transferable use case, but it's far from the only thing Ouvvi handles for us. A few others worth noting:

Helpdesk email processing

Our helpdesk is built in-house, and Ouvvi acts as its nervous system. Separate projects handle: pulling incoming queries from Exchange, relaying messages between our Ouvvi environment and helpdesk system to create asynchronous tasks, sending replies via a web API endpoint, and removing spam users flagged in the system. Each of these runs as its own project within our Ouvvi instance, so they can be triggered and monitored independently.

Application deployment

A dedicated Ouvvi instance handles the build and deployment pipeline for our own applications, including our website and our helpdesk through staging and into production. This keeps deployments consistent and allows us to check in at each stage.

Backups and licence management

Licence key backups run on a start-of-day trigger, using a Data Sync step to copy the database to backup storage. If the backup fails, a notification goes out to us immediately. We also run a project that updates end dates on offline licence files so customers can download a refreshed file before their current one expires after renewing. This is triggered by both new licence events and a daily start-of-day check.

The bigger picture

What ties all of this together isn't any single clever piece of automation, it's the approach. Ouvvi gives us a central place to define, schedule, monitor, and receive alerts from every automated process in our operation. Data Sync gives us the connectors to move data between the systems those processes use.

We know exactly where our data is at every point. We know what triggered each process, what it did, and whether it succeeded. When something fails, we find out immediately. When we want to add a new process or change an existing one, we don't need to go via a third-party platform — we just build it in Data Sync and Ouvvi.

We've been building data automation tools for years. Using them ourselves, for real operational problems, it’s how we keep them reliable.

If you’ve got questions, have an idea that you want to know if it’s possible, or you do have a feature request that will help make your processes easier – reach out to us and we will happily talk through your ideas.