Netlify Functions and Identity: what you can actually do without hiring a developer

This page may contain affiliate links from which Blur Studio earns commissions.

Netlify is a hosting platform most commonly used for static sites and modern frameworks like Next.js or Astro. Two of its features come up constantly once a site needs to do more than show pages: Functions, for running server-side code, and Identity, for letting visitors log in. Both are genuinely useful, and both get overstated in different directions, Functions sometimes made to sound harder than it needs to be, Identity sometimes made to sound simpler than it actually is once you need anything beyond basic login.

What Netlify Functions actually do

A static site is just files: HTML, CSS, images, served exactly as they are. That works for a huge amount of a typical business website, but some things need a server to actually run code when a request comes in, not just hand back a pre-built file. Netlify Functions are that: small, individual pieces of server-side code, deployed alongside your site, that run on demand in response to things like a web request, a form submission, a new user signing up, or your site finishing a deploy. For scheduled jobs, see how to run a daily or weekly task automatically without a server.

Common real-world uses for a small business site: sending a notification email when a form is submitted, checking a promo code against a list before applying a discount, calling a third-party API (a shipping rate calculator, a payment processor) that can't safely run in the visitor's browser because it needs a secret key. Netlify's own documentation describes Functions as deployed and version-controlled alongside the rest of your site, with deploy previews and instant rollbacks the same way your pages get them, which is a genuine convenience over managing a separate server yourself. The CRM, payment and booking case is covered in how to connect your website to a CRM, payment or booking tool.

What Netlify's public documentation does not spell out in specific numbers, at least on the pages I could check directly, are hard invocation or execution-time limits per plan. Netlify's current pricing instead runs on a credit system (confirmed live on netlify.com/pricing as of October 2026): compute use is metered at 10 credits per GB-hour, roughly $0.07, so Functions usage is billed by actual compute consumed rather than a fixed monthly cap you might hit and get cut off at. If exact numeric limits matter for your specific project, confirm them directly against your account's current plan before building something that depends on a particular ceiling.

What Netlify Identity actually does

Identity is Netlify's own built-in system for letting people create accounts and log into your site: email and password signup with a configurable confirmation email, login through external providers like Google or GitHub, role-based access control so you can restrict parts of a site to certain users, and account recovery flows for forgotten passwords. Despite some older commentary online suggesting Netlify was winding it down, the current Netlify documentation I checked directly (last updated in March 2026) actively recommends it and confirms it ships at no extra cost on every credit-based plan, so it's worth checking the current docs yourself rather than trusting an outdated blog post if you're deciding whether to use it. For a simpler setup, see how to add a members-only or password-protected area to part of your site.

Netlify's own documentation describes two ways to add it: through an AI agent runner inside the Netlify dashboard, which sets most of it up for you, or by manually installing the @netlify/identity package and wiring it into your site's code by hand.

What a non-developer can genuinely do alone

• Add basic login with Identity through an agent runner. If your site was built through an AI tool connected to Netlify, asking it to "add login with email and password" is a realistic request, and Identity is built specifically to make that an agent-runner-friendly setup rather than something requiring hand-written authentication code.
• Use a pre-written, simple Function with minor edits. A short function someone else wrote, say one that forwards a form submission to a Slack channel, is usually editable by a non-developer changing a URL or a message text, without understanding the whole file.
• Ask an AI coding agent to write a short, well-defined function from scratch. "Write a function that checks if a discount code matches this list and returns yes or no" is specific enough that an AI agent can usually produce something workable, especially if you can test it and catch obvious failures.

A realistic cost picture for a small setup

Say a small site adds a simple login (through Identity) and one Function that sends a notification email on signup. On Netlify's current credit-based pricing, confirmed live as of October 2026, Identity itself costs nothing extra on any credit-based plan, and a single lightweight Function firing occasionally (a few hundred signups a month, say) will consume a genuinely small slice of compute credits, likely well inside what the Free plan's 300 monthly credits or the $9 Personal plan's 1,000 credits already cover. The actual Netlify cost of adding this kind of feature to a small site is realistically close to $0 extra for most small businesses; the real cost, if there is one, is almost always the time spent getting the edge cases right, not the hosting bill.

Where you genuinely need a developer

• Anything handling real customer data or payments. A function that touches payment details, personal data, or anything with compliance implications needs someone who understands security properly, not a best-effort AI-generated script nobody has reviewed.
• Role-based access with real business logic. "Only paying customers can see this page" sounds simple and gets complicated fast once you add tiers, trial periods, or partial access, exactly the kind of logic that's easy to get subtly wrong without someone checking it carefully.
• Debugging a function that fails intermittently. A function that works most of the time but fails under specific conditions (a slow third-party API, an edge case in the input) is genuinely hard to diagnose without being comfortable reading server logs and code, and this is one of the more common reasons a non-developer eventually brings someone in.
• Anything where a mistake is expensive. If getting it wrong means a broken checkout, a security gap, or locked-out customers, that's worth a developer's time even for something that looks simple on the surface.

A worked example: a login-gated resources page

Say you want a page on your site that's only visible to people who've signed up. With Identity, the login and signup flow itself is realistically something an agent runner can set up, since that's exactly the use case Netlify built it for. Where it gets harder: deciding what happens for a user whose signup wasn't confirmed, handling what shows up if someone's session expires mid-page, and making sure the restricted content genuinely isn't accessible by just guessing the URL. Those edge cases are where a short AI-assisted setup quietly turns into a half-day of real debugging, and it's usually cheaper to have a developer get it right the first time than to pay for the AI tool's and your own time repeatedly circling the same bug.

How I'd approach this

My honest read: Identity for basic login, and a short, well-scoped Function doing one clear job, are genuinely within reach for a non-developer working with an AI agent runner inside Netlify. The moment real data, money, or anything security-sensitive touches that code, or a function starts failing in ways you can't explain, that's the point to bring in a developer rather than keep iterating with an AI tool that's already shown it can't fully solve the problem. I take on exactly this kind of work: fixing a half-built Functions setup or adding the login and access logic a non-developer got most of the way to but couldn't finish safely alone.