Napkin

What Napkin actually is

Napkin is a browser-based serverless function platform: you write code in an editor that lives on a web page, press run, and it becomes an HTTP endpoint. No CLI, no repository, no deploy pipeline, no cloud account. The functions run Node.js or Python — the marketing pages lean on "JavaScript" but the docs are explicit that Python is a first-class option alongside Node.js — and every function automatically gets an HTTPS URL, endpoint SSL, and auth. For webhooks, bots, quick integrations, and the kind of internal glue code that never justifies a real backend, that workflow is as short as it gets.

The product shape is deliberately small. Unlimited functions and workspaces on both tiers, production logs, scheduled function triggers, access to a large module ecosystem (the pricing page advertises 300k+ modules), custom domain support, and team invites even on the free plan. The editor runs your code in-browser for development, and deployment is a one-click affair — according to the company, deploys happen instantly with no waiting. The first build of your account environment takes up to 30 seconds; after that, edits and runs are immediate.

Who builds on it: people who need an endpoint today. A Stripe webhook receiver, a Slack bot, a cron job that posts to Discord, a mobile app's thin API layer, a prototype for a client demo. Napkin's own framing is "backend in the browser," and that is the honest description — it is the backend you write when writing a backend should take ten minutes.

Pricing: what you really pay

The free plan is the headline and it is real: $0 per month for instant API endpoints, endpoint SSL and auth, unlimited functions and workspaces, production logs, scheduled triggers, custom domains, and team invitations. The ceilings are what you give up: 500 MB of memory and 0.5 vCPU per function, a 15-second function timeout, 25,000 API calls per month, and 5 requests per second. For a webhook receiver or a personal automation, 25,000 calls a month is plenty; for anything user-facing, you will hit it.

The Pro plan is $10 per user per month and lifts the same ceilings: 2 GB of memory and 2 vCPU, a 30-second timeout, 500,000 API calls per month, and 25 requests per second. Everything else stays identical — the plan difference is purely capacity and rate limits, which is a pricing structure we like. There is no feature gating dressed up as tiers, no sales call, and no annual contract on the published page.

One warning about stale figures: some third-party pages and even a Napkin solutions page quote older numbers — 1 GB of memory, 1,000,000 free API calls per month, or "5,000 free monthly API calls" on aggregator sites. Those contradict the current pricing page, and where they conflict we treat the pricing page as authoritative and the others as stale. If you are budgeting against a specific call volume, verify the current limits on the pricing page the day you commit.

Against the mainstream serverless options, the arithmetic shifts with scale. At 25,000 calls a month, Napkin costs nothing and requires no infrastructure knowledge; the same workload on a hyperscaler's functions platform is also nearly free but comes with an account, IAM, a region choice, and a billing alarm. At 500,000 calls a month, Napkin Pro at $10 per user per month is still trivially cheap. The comparison changes only when you need what Napkin does not publish at all: regions, cold-start behavior, or an uptime commitment.

Performance & infrastructure

This is where we have to be plain about what is knowable. Napkin publishes per-function resources (500 MB / 0.5 vCPU free, 2 GB / 2 vCPU on Pro), timeouts (15 seconds free, 30 seconds Pro), and rate limits (5 requests per second free, 25 Pro). Those are real, useful numbers and they tell you exactly what workload fits. What is not published anywhere we could find is the underlying infrastructure: which cloud it runs on, which regions are available, cold-start latency, or any uptime SLA. We have not benchmarked Napkin ourselves and will not quote performance figures we did not measure — see our benchmarks for what we do test.

What can be said architecturally: functions are invoked over HTTPS with endpoint SSL and auth handled for you, execution is bounded by the memory, vCPU, and timeout per plan, and the platform scales automatically — the company says functions scale to handle thousands of calls a day without configuration. Scheduled triggers let functions run on a timer, which covers most cron-style automation. Production logs give you the minimum observability needed to debug an endpoint without deploying a logging stack.

The 15-second timeout on the free tier deserves attention because it constrains design more than the call quota does. Anything that makes a slow third-party call, processes a large payload, or generates something heavy will need the Pro tier's 30 seconds — or a queue in front of it. Likewise the 5 requests per second free-tier cap means a traffic spike gets throttled at the endpoint, which is a reasonable protection for a free plan and a hard limit for anything with real users.

On reliability track record: Napkin is a small product from a small team, not a hyperscaler. There is no public status history or SLA we can point to, and the reviews we found are developer word-of-mouth rather than enterprise references. That is fine for prototypes and personal automation and disqualifying for anything whose failure costs money.

Where it falls short

Production readiness is the honest limit. No published SLA, no published regions or data residency, no cold-start numbers, and rate limits that cap at 25 requests per second even on the paid tier. If your API has real users and real revenue behind it, you are one vendor hiccup away from an outage with no contractual recourse. The company is explicit that functions scale to "thousands of calls a day" — that is the design target, and it is not a platform for sustained high-throughput workloads.

Second, the browser-only workflow is a feature until it is not. There is no local development story of the kind serverless developers expect, no infrastructure-as-code, and no obvious path to export your functions into a conventional deployment. Code written in Napkin lives in Napkin. For throwaway prototypes that is fine; for a system you expect to grow, budget for a rewrite.

Third, the language story is narrower than "bring your own runtime": Node.js and Python, and that is the list. Anything else — Go, Rust, PHP, Ruby — is out.

Fourth, the documentation is thin at the edges and the stale-limit problem cuts both ways: if the marketing pages still quote 1 GB and 1,000,000 calls, it is hard to trust that all operational limits are current and enforced consistently.

Who should pick this

Our pick for developers who need an HTTP endpoint today and do not want to open a cloud console: webhook receivers, bots, scheduled automations, hackathon backends, and client prototypes. The free tier is genuinely usable — 25,000 calls a month with custom domains and team invites is enough for real personal projects — and the step to Pro at $10 per user per month is small and purely capacity-driven. Scheduled triggers make it a decent home for the small cron jobs that otherwise live on a forgotten VPS, and team invites mean a two-person project can share a workspace without ceremony.

We would look elsewhere for anything with paying users, uptime requirements, data residency needs, or throughput beyond 25 requests per second. For those workloads, a mainstream functions platform or a small always-on server gives you published regions, SLAs, and an exit path — compare our serverless platforms category and our benchmarks before you commit a production system.

Key takeaways

• Browser-based Node.js and Python functions that deploy as authenticated HTTPS endpoints in one click — the shortest path from idea to URL.
• Free plan: $0/month, 500 MB memory and 0.5 vCPU per function, 15-second timeout, 25,000 API calls per month, 5 requests/second.
• Pro plan: $10 per user per month for 2 GB memory and 2 vCPU, 30-second timeout, 500,000 calls per month, 25 requests/second — same features, more capacity.
• Unlimited functions and workspaces, production logs, scheduled triggers, custom domains, and team invites included on both tiers.
• No published SLA, regions, or data residency; small-vendor reliability — prototypes and automation, not revenue-critical APIs.
• Watch for stale limit figures on third-party pages; the pricing page is the reference.

Sources

• https://napkin.io/pricing
• https://napkin.io
• https://docs.napkin.io/guides/quick-start
• https://napkin.io/solutions/serverless-for-mobile-apps
• https://findfree.org/resource/napkin