← Back to all posts

Your App Should Keep Working After You Close the Tab

Your App Should Keep Working After You Close the Tab

Building an app isn't only about what happens when somebody clicks a button.

Real businesses also need things to happen later.

Tomorrow morning.

Three days after an invoice is due.

One day before an appointment.

Every Monday at 9 AM.

Until now, adding that kind of behavior usually meant thinking about cron jobs, background workers, queues, retries, timezones and a surprising amount of backend infrastructure.

Kreova now handles that for you.

Just tell the agent when something should happen

You can describe scheduled behavior in normal language.

For example:

"Email me a summary every Monday at 9am."

Kreova can create a recurring digest that runs automatically.

It can filter the data:

"Only include leads where status is new."

And calculate useful totals:

"Include the number of leads and the total pipeline value."

The finished app doesn't need you sitting in the builder.

The schedule keeps running.

Reminders from your app's own data

Suppose you're building a booking system.

You can say:

"Remind the customer 1 day before their appointment."

Kreova can use the appointment date stored in the database, find the customer's email address from that row, and send the reminder when the time arrives.

The same pattern works for much more than appointments.

"Send a renewal notice 7 days before expiry."

"Chase unpaid invoices 3 days after the due date."

"Remind members 30 days before their subscription expires."

These aren't timers you have to recreate manually for every customer.

They're rules attached to the application's data.

Your app can change its own records too

Not every scheduled action needs to send an email.

You can tell Kreova:

"Mark invoices overdue 14 days after the due date."

When the time arrives, the app can update the invoice automatically.

And because that is a normal data change, it can trigger the rest of your application's workflow.

For example:

  1. An invoice reaches 14 days past due.
  2. Kreova changes its status to overdue.
  3. The existing "status changed to overdue" notification runs.
  4. The customer receives an email.

One scheduled rule can feed directly into another part of the application.

Digests, reminders and automatic actions

The first version of scheduled automations supports three useful patterns.

Digests

Run hourly, daily, weekly or monthly.

They can filter records and calculate things such as counts and totals before sending the result by email or webhook.

Example:

"Every Friday at 5pm email me all completed jobs this week and the total revenue."

Reminders

Fire relative to a date stored on a record.

Before it:

"Remind the customer 24 hours before the booking."

Or after it:

"Follow up 3 days after the consultation."

Each reminder fires for the relevant record rather than blindly sending the same message to everybody.

Flags

Automatically update data when a date passes.

Example:

"Set subscriptions to expired when the expiry date passes."

That update becomes part of the normal application workflow just like an update made by a user.

This is what we mean by full-stack

Generating the page was never the hardest part.

An application also needs to:

  • store data
  • authenticate users
  • protect that data
  • accept payments
  • upload files
  • send email
  • call webhooks
  • enforce business rules
  • and now, do work on a schedule

The goal with Kreova is that you shouldn't have to assemble a separate service every time your app needs one of those capabilities.

You describe what the application should do.

Kreova connects the pieces.

And it keeps running after the AI is finished

This is the part we care about most.

You can build the booking system, close Kreova, and tomorrow the reminder still sends.

You can build the CRM, leave for the weekend, and Monday morning the sales digest still arrives.

You can build the invoicing app, and overdue invoices can still be marked automatically.

The AI doesn't just generate something and disappear.

It creates behavior that becomes part of the application.

Your app should keep working even when you're not.