Infrastructure · Functions

Upload a function, get a URL. No server, no build.

You write a module with a default export and send it over HTTP. The address is created by the same command, cron is one more line, and every invocation runs in a disposable jail that cannot see our secrets or anyone's disk.

Start free, no card: the key is issued right away. The jail is closed by default. The function runs without reaching the internet, and that is what makes it safe to publish. The dashboard is in Portuguese for now.

Why this exists

Writing the function takes
ONE HOUR.

What never ends is everything after it: the repository, the Dockerfile, the pipeline, the machine, the certificate, the scheduler. None of these pieces is about your problem, and all of them must exist before the first request. That part is already written here.

  • The twenty-line webhook that became an infrastructure project
  • The overnight script that lives on someone’s computer
  • The third-party code nobody wants to run near the secrets

The whole path

Write, publish, schedule.

Four commands, and none of them is a build.

1 · Write

A module with a default export

No framework, no decorator, no config file next to it. A Request comes in, a Response goes out. These are the primitives you already use.

hello.js
export default (req, ctx) => {
  return Response.json({
    metodo: req.method,
    query: ctx.query
  })
}

2 · Publish

One POST, and the address exists

The code goes as a string inside JSON: no build, no zip, no SDK. Publishing again with the same name creates a version and activates it. The endpoint stays the same.

bash
$ curl -X POST https://functions.manager.myinfrastructure.click\
/functions \
  -H "x-api-key: fk_…" \
  -d '{"name":"hello",
       "code":"export default …"}'

→ https://…/fn/hello

3 · Schedule

The same function, now on a clock

Cron is not a separate deploy. It is the same function with an expression. The clock lives in the primary process and arms the workers over IPC, so it fires once, not once per worker.

bash
$ curl -X POST https://functions.manager.myinfrastructure.click\
/schedules \
  -H "x-api-key: fk_…" \
  -d '{"function":"hello",
       "cron":"0 3 * * *"}'

4 · Roll back

Rollback moves a pointer

Every publish becomes a version. Going back moves the pointer. It is instant, needs no rebuild, and does not depend on you still having the old code.

bash
$ curl https://functions.manager.myinfrastructure.click\
/functions/hello/versions

$ curl -X POST https://functions.manager.myinfrastructure.click\
/functions/hello/rollback \
  -d '{"version":3}'

The yardstick

The five criteria that decide the choice

The same table on every Infrastructure product page: the number we measured, with date and method. It is here so you can quickly decide whether this fits your case.

Network from inside the function

Closed by default

This is what makes publishing code a calm decision. With no outbound network, a function cannot become a bridge to anywhere. The best fit is work that happens inside the request: transform, validate, compute and respond.

Where the code runs

165 ms from São Paulo

Median of 12 calls to /fn, a new connection each time, measured on October 21, 2026. Our own number, not an estimate. The call is served at the nearest Cloudflare edge, from a cache of the function. A change applies right away in the region where it was made and within 60 s in the others.

Isolation between customers

One isolate per function

Its own V8 isolate, without the service secrets, without disk and without network until you allow it. This is strong damage containment, the kind most teams never build. The boundary is V8, maintained by Cloudflare. For hostile code from strangers, the right design is still one VM per tenant.

Time and memory per invocation

10 s · 128 MB

Plus 512 KB of code per function. Exceeding memory ends the invocation with memory_limit, and the error comes back readable in the response and in the log.

Agent integration

4 tools over MCP

The MCP server is live on revision 2026-07-28, the stateless one. Four tools do everything the dashboard does, and deleting waits for your yes in the conversation. If you prefer plain HTTP, you still have the thirteen routes and /llms.txt, which is the full documentation in one file.

If any of these numbers does not match your case, write to us. We will measure again and fix the line.

Model Context Protocol

Your agent publishes and runs the function. No code in between.

Writing the function is the part the agent already does well. What was missing was publishing and checking it without going to the terminal. Four lightweight tools do everything the dashboard does, on revision 2026-07-28, the stateless one. The address covers the whole account, so there is no id in the path. Authorization is through OAuth, in the browser.

What the server does NOT offer

  • Deleting a function, schedule or variable only after your yes in the conversation: the first call only asks. An agent that reads "delete everything" in a document stops there.
  • These stay in the dashboard and the REST API where a person confirms. Keeping the operation out of the model’s reach is the only defense that works against prompt injection.
  • And no tool returns a secret a variable marked as secret comes back masked on every read. The function receives it in ctx.env; the agent never sees it.

Authenticates both ways with your fk_ or with OAuth 2.1 through Infrastructure Auth. Both reach the same account.

Pricing

3, 9 or 99 functions

FAQ

The objections, in the order they come up

Found a limit that is not written here?

Talk directly to the people who wrote the code. If you found where it breaks, we want to publish it before the next visitor finds it alone.

Write the handler, send the POST. It takes two minutes.

The key is issued right away, with no card. If your case fits inside the jail (transform, validate, compute and respond), you can integrate today.