Chapters: 
O365 Plumbing

Python HTTP-triggered Function.

To grasp the core idea without burying you in Azure furniture. Microsoft’s current recommendation for new serverless Function apps is Flex Consumption, not the older Linux Consumption plan. It scales to zero, supports Python 3.10 through 3.14, and is the path Microsoft is actively steering new workloads toward. (Microsoft Learn)

Let's do this tour in three passes:

  1. Create it in the portal first. In portal.azure.com, search for Function App → Create. Choose Flex Consumption, Linux, Python, and whatever region is convenient. Keep the defaults unless Azure asks you to create a storage account. The goal here is simply to see what resources Azure creates around your code.

  2. Make one HTTP trigger. Think of it as a tiny REST endpoint:
    GET /api/hello?name=Ali
    → Python runs
    → returns Hello Ali.

    This teaches the essential Azure Functions model: your code is not “a server”; it is code attached to a trigger. HTTP is merely the easiest trigger to see.

  3. Then redo the exact same thing locally. Install Azure Functions Core Tools, create a Python venv, run the Function locally, then deploy it. Microsoft’s current Python quickstart follows exactly that path and deploys to Flex Consumption. They estimate the exercise costs only a few cents or less. (Microsoft Learn)

The conceptual map I’d keep in your head is: 

Function App
│
├── Function: hello
│      Trigger: HTTP
│      Python code
│
├── Function: process_upload
│      Trigger: Blob created
│      Python code
│
└── Function: nightly_job
       Trigger: Timer
       Python code

That is the interesting bit. Azure Functions is essentially an event router into your Python.

Given your background, I would resist tutorials for a while and inspect the thing you create. In the portal, look at Overview, Functions, Configuration / Environment variables, Identity, Monitoring, and Application Insights. Those six screens tell the Azure story much better than forty pages of beginner documentation.

Then make your second function a timer trigger. Something absurdly simple, perhaps every five minutes: 

timer fires
    ↓
Python
    ↓
log "Camelot still stands"

Now you’ve seen both major species: 

request-driven             event-driven

HTTP ──→ Function          Timer ──→ Function
                              
later:
Blob ──→ Function
Queue ─→ Function
Event Grid ─→ Function

And that third step, Blob Storage → Function, is where I think it becomes genuinely useful for you. A file appears somewhere, Python automatically processes it. Suddenly all those workflow questions you've been circling around SharePoint, automation, imports and knowledge-management pipelines have an Azure-native counterpart.

One warning while exploring: when Azure asks about Always Ready instances, leave them off for this experiment. Flex Consumption's ordinary on-demand instances scale to zero and have monthly free grants; Always Ready instances incur baseline billing. (Microsoft Learn)

So I’d literally begin now at:

Azure Portal → search “Function App” → Create

and if you want, tell me what you see on the Create Function App screen and we can walk through the choices together rather than following a canned tutorial.

Azure