Skip to main content
← All insights

By

CTO @ Beautron.AI · AI Product Engineer

3 min read

Azure / Serverless / Cost / Architecture

Serverless for the boring 80%

Most of a platform's background work (notifications, reports, scheduled jobs, integrations) doesn't need always-on servers. Moving it to Azure Functions and Logic Apps is how we cut operational costs by 30%.

At e-DestinAccess we reduced operational costs by 30% by automating business processes with Azure Functions and Logic Apps. None of it was glamorous. It came from looking at what our always-on servers actually spent their time doing, and noticing that most of it was background work that didn't need them.

Find the boring work

Look at any mature web platform and you'll find the same kinds of jobs living inside the main application or on a dedicated "worker" VM:

  • sending booking confirmations, reminders, email and SMS,
  • generating and emailing reports,
  • nightly clean-up, sync and reconciliation jobs,
  • moving files between systems, and calling partner APIs on a schedule.

These jobs are bursty or periodic, independent of user requests, and easy to retry. That's exactly the shape serverless is priced for: you pay per execution instead of for idle capacity.

Functions for code, Logic Apps for integration

I use the two services for different jobs:

  • Azure Functions for logic that belongs in code and in your repository: transforming data, calling your own domain services, anything that needs unit tests. We built our notification pipeline this way, sending email through SendGrid and SMS through Azure Communication Services.
  • Logic Apps for integration workflows made mostly of connectors, such as "when a file lands in Blob Storage, parse it, call this API and notify that mailbox". They're visual, quick to change and easy for operations staff to read, and they keep plumbing out of your codebase.

The rule of thumb: if the workflow is mostly glue, use a Logic App; if it's mostly logic, use a Function.

Design rules that keep it cheap and reliable

Queue everything in between. The web app shouldn't call a Function directly; it should drop a message on a queue. The request returns immediately, spikes are absorbed by the queue, and failed messages are retried and eventually land in a poison queue you can inspect.

Make every handler idempotent. Queues deliver at least once. A notification handler must check whether "booking 123 confirmation" was already sent before sending it again.

Keep functions small and single-purpose. One trigger, one job. Small functions start faster, are easier to reason about and fail in isolation.

Watch the cold start. Consumption-plan functions can take a moment to start. That's fine for an email and not fine for a checkout. Keep user-facing, latency-sensitive paths on always-on compute, or use a premium plan with pre-warmed instances.

Put cost on the dashboard. Serverless is cheap until a retry loop runs a function millions of times. Set budget alerts, and watch execution counts in Application Insights the same way you watch errors.

When not to go serverless

  • Long-running or stateful processing fits better in containers or Durable Functions with explicit orchestration.
  • Steady, high-volume workloads can be cheaper on reserved compute. Serverless wins on spiky or idle-heavy work.
  • Chatty internal calls between many tiny functions add latency and failure points. Don't turn a clean module into a distributed system just because you can.

Takeaways

  • Audit what your always-on servers spend time on; the background jobs are usually the opportunity.
  • Use Functions for logic and Logic Apps for integration glue.
  • Put queues between the app and the background work, and make handlers idempotent.
  • Keep latency-sensitive paths off cold starts, and watch cost like an error rate.

Working on something similar? Let's talk — or ask ARA, the assistant in the corner, about this article.

More insights