I've been working with Azure's serverless portfolio and I think it's worth understanding the four main pieces: Functions, Logic Apps, Event Grid, and API Management. Knowing what each one is good for makes a big difference when designing event-driven systems.

Azure Functions is the compute part of the serverless model, where you write the code and Azure handles the runtime, scaling, and infrastructure. The consumption plan is perfect for intermittent workloads, and functions can be triggered by HTTP, timers, blob storage events, and more.

In production I've seen the cold‑start latency bite us hard on the consumption plan – a fresh instance can take five to ten seconds to spin up, which is unacceptable for user‑facing APIs. The workaround is to move to the Premium plan or enable pre‑warmed instances; that adds a predictable cost but eliminates the pause. Also remember the per‑function scaling ceiling of about 200 instances; if you expect spikes beyond that you have to shard the workload across multiple function apps and keep an eye on the metrics in Azure Monitor. I always wire Application Insights into the function to catch the silent failures that only surface in the logs after a night‑time outage.

When it comes to integration, Azure Logic Apps is the way to go. It provides visual workflow orchestration, connecting SaaS systems like Salesforce and Office 365, handling data transformation, and approval workflows. With over 400 connectors and pre-built authentication and error handling, Logic Apps saves you from writing a lot of boilerplate code.

Azure Event Grid is the event routing fabric, taking events from Azure services and custom applications and routing them to subscribers like Functions, Logic Apps, and webhooks. The push‑based model with automatic retries and dead lettering ensures reliable event delivery without polling, making it the glue between Azure services in serverless architectures.

When you start pushing a few hundred thousand events per minute through a single topic, the default 500k events‑per‑second limit can be reached faster than you think. I ran into a case where a mis‑configured filter dropped half the events and the dead‑letter storage filled up silently, causing downstream functions to starve. The fix was to enable the dead‑letter endpoint to an Azure Storage account, set up alerts on the blob count, and tighten the filter logic. Using Azure CLI to script topic creation also helped keep the naming consistent across dev, test, and prod environments.

In 2019, Azure introduced Durable Functions Entities, which implement the actor pattern in a serverless context. An entity is a stateful, addressable unit of computation, like a shopping cart or an order state machine, that persists state between invocations without needing a database. Multiple entity instances can run concurrently, with signals to the same entity serialised.

Durable Entities store their state in Azure Storage tables, which means you have to watch the 10 MB per entity limit – a shopping cart with a million line items will hit that ceiling quickly. I've also seen orchestrations that run longer than the 10‑minute timeout on the consumption plan get cut off, forcing a move to the Premium plan or breaking the workflow into smaller sub‑orchestrations. Versioning the entity code is another pain point; a small change to the state schema can cause deserialization errors unless you migrate the old state explicitly.

The actor pattern combines the scalability of serverless with the statefulness of actors, making it a powerful tool for certain types of applications. By understanding how each of these serverless pieces fits together, you can design more effective event-driven systems.

Azure Functions, Logic Apps, and Event Grid each have their own strengths and use cases. Functions are great for custom compute, Logic Apps for integration, and Event Grid for reactive patterns. By choosing the right tool for the job, you can build more efficient and scalable serverless architectures.

The key to getting the most out of Azure's serverless portfolio is understanding when to use each service. With a clear understanding of the strengths and weaknesses of each piece, you can design event-driven systems that are more efficient, scalable, and reliable.

By combining Azure Functions, Logic Apps, Event Grid, and API Management, you can create a complete event-driven serverless architecture that meets the needs of your application. Each service has its own role to play, and by understanding how they fit together, you can build more effective and efficient serverless systems.