Callables vs Power Automate: running Python automations for your team

If your company runs on Microsoft 365, Power Automate is probably already available to you. It's excellent at what it was built for: approvals in Teams, saving Outlook attachments to SharePoint, updating an Excel sheet when a form comes in. And with desktop flows, it can even click through old Windows apps that have no API.

Where it gets harder is when the automation is really Python: a script with real logic, packages and tests behind it. This post covers where each tool fits.

Different starting points

Power Automate starts from flows. You build a flow in a visual designer from triggers, connectors and actions, and Microsoft's Copilot can draft one from a description. It's designed so people who don't code can automate their own work.

Callables starts from code. You write a normal Python function in your repo, in your own editor with your own AI agent, and add @deploy. Callables turns it into a form your team can run, with schedules and a history of every run:

from datetime import date

from callables import deploy


@deploy(title="Month-end close report", secrets=["ERP_TOKEN"])
def month_end(
    month_start: date,
    include_drafts: bool = False,
) -> list[dict]:
    """Summarizes journal entries for the month, by account."""
    ...

Running Python in Power Automate

Power Automate doesn't have a built-in way to run Python in a cloud flow. The usual options are:

• Host the code somewhere else, such as an Azure Function, and call it from the flow with the HTTP action or a custom connector. That works, but now you're deploying and maintaining a separate service, and the HTTP action and custom connectors are premium features.
• Use a desktop flow, which can run a Python script on a Windows machine with Python installed. That machine has to be set up and kept running, and unattended runs need the Process plan.

Either way, the Python ends up separate from the flow that runs it, and you maintain both.

With Callables, the Python is the automation. There's no separate service to host and no machine to keep running: push your repo, and every @deploy function is built and ready to run, with its dependencies from your requirements.txt (more on builds). Each push to your branch deploys the latest version.

Who runs it

Power Automate flows usually start from a trigger, a schedule or a button, and approvals bring people in along the way.

Callables gives every function a form built from its inputs: a date picker for month_start, a checkbox for include_drafts. Teammates who don't code fill it in and click Run. You decide who can run each function, and every run keeps its inputs, logs and result.

Pricing

Power Automate is licensed mostly per user. Many Microsoft 365 plans include it for standard connectors. Premium connectors, including the HTTP action, need Power Automate Premium at $15 per user per month (billed yearly). Unattended desktop flows need the Process plan at $150 per bot per month, or Hosted Process at $215 with a Microsoft-hosted machine included.

Callables has no per-seat price. Pro is $20 a month per team, with $20 of usage included and unlimited people, so adding the teammates who only run things doesn't change the bill. Hobby is $5 a month. See pricing.

At a glance

Using both

The two work well together. Webhooks are coming to Callables soon, giving each function a URL other systems can call. A Power Automate flow can then catch the event in Outlook, Teams or SharePoint and hand the heavy lifting to a Callables function, and you'll also be able to run functions from your own code through the API.

Which one to use

Use Power Automate when the work lives in Microsoft 365, needs approvals, or means driving a desktop app that has no API.

Use Callables when the automation is really Python: it has logic worth testing, needs packages, or should be something a teammate can run with the right inputs, without anyone hosting a separate service. Write the function, push it, and your team has a tool.