Backend development is a story of ever-increasing abstraction. We moved from physical servers to VMs, from VMs to containers, and from monolithic applications to microservices. Each step aimed to reduce complexity and increase scalability. Yet, for many developers, the dream of a simple, focused development experience remains just out of reach.
We still spend countless hours on boilerplate, infrastructure configuration, API gateways, and deployment pipelines. Even with "serverless," we often find ourselves wrestling with a complex web of cloud services just to expose a single piece of logic.
What if we could take the next logical leap? What if we could stop thinking in terms of servers or even services, and instead focus on the most fundamental unit of logic: the function? This is the new mental model for backend development, and it's powered by a simple, radical idea: Deploy a function, get an API.
The microservices revolution was a reaction to the unwieldy nature of monoliths. Breaking down a large application into smaller, independent services solved many problems related to deployment cycles and team autonomy. But it also introduced a new class of complexity:
We traded one kind of complexity for another. The core business logic—the valuable part—was often buried under layers of undifferentiated heavy lifting.
The solution is to zoom in further. Instead of building a "User Service," what if you just built the functions it contains?
This is the core of "thinking in functions." We embrace the atomic function: a small, self-contained unit of code designed to perform one specific task perfectly. It adheres to the single-responsibility principle in its purest form.
When you write a function this way, it becomes incredibly easy to reason about, test, and reuse. The scope is small, the purpose is clear, and the cognitive load is minimal. The only missing piece has been the bridge: how do you take this pure, simple function and make it a production-ready API without recreating all the complexity of a "service"?
This is where function.do changes the game. We provide the missing bridge. You write your logic as a standard function, and we handle everything else.
Consider this simple TypeScript function to generate a greeting:
import { Do, Fn } from '@do-are/sdk';
/**
* @description Generates a personalized greeting.
* @param { name: string } - The name to include in the greeting.
* @returns { message: string } - The personalized greeting message.
*/
export const getGreeting: Fn = async ({ name }) => {
if (!name) {
throw new Error('A name is required to generate a greeting.');
}
const message = `Hello, ${name}! Welcome to the platform.`;
// This object is returned as the JSON API response.
return { message };
};
// Deploying this creates a unique API endpoint:
// POST https://your-name.function.do/getGreeting
// BODY { "name": "World" }
With function.do, the moment you deploy this file, you get a live, secure, and infinitely scalable API endpoint. There are no servers to configure, no frameworks to install, and zero boilerplate to write. Your function's logic is the API.
"This is great for simple tasks," you might think, "but how do I build a real application?"
The answer lies in composability.
Because every function on function.do is an independent API endpoint, you can easily "compose" them to build complex workflows. One function can call another using a simple HTTP request or our SDK.
Imagine a processNewOrder function. Internally, it could make calls to two other atomic functions you've deployed:
Each function remains simple, atomic, and independently scalable. chargeCard can be maintained by the payments team, while updateInventory is owned by the logistics team. Your processNewOrder function acts as an orchestrator, composing these simple, reusable blocks into a powerful business workflow. This is the promise of microservices fulfilled without the operational overhead.
Platforms like AWS Lambda or Google Cloud Functions are powerful, but they are building blocks, not a finished solution. To expose a Lambda function as a public API, you still need to configure an API Gateway, set up IAM roles, manage permissions, and wire everything together.
function.do is different because it offers radical simplicity. We provide a complete, production-ready solution out of the box. You provide the logic; we instantly provide the secure, scalable, and documented serverless API. It's the Function as a Service (FaaS) experience you've always wanted.
And yes, you can bring your ecosystem with you. Need a package from NPM? Just add a package.json file, and we'll handle the rest.
Adopting this new mental model means shedding the baggage of the past. Stop building services and start writing functions. Focus on the single, valuable task at hand and let the platform handle the rest.
This shift simplifies your code, streamlines your deployments, and frees you to build better products, faster.
Ready to turn your functions into APIs? Get started with function.do and experience the future of backend development.