Introducing the Functions.do SDK: Ship Reliable APIs, Not Infrastructure

In modern software development, the distance between writing a piece of business logic and deploying it as a production-ready, reliable service can be vast. You write your core function—the code that delivers actual value—and then the real "work" begins: setting up servers, configuring API gateways, writing validation layers, managing environments, and orchestrating deployments. This boilerplate is not just tedious; it's a source of bugs and a drain on productivity.

What if you could skip all that? What if you could transform your business logic directly into a typesafe, production-ready API, and focus solely on the code that matters?

Welcome to Functions.do. We're excited to introduce our SDK, built on a simple yet powerful philosophy: you should ship reliable APIs, not spend your time managing infrastructure.

From Code to Chaos: The Old Way

Let's be honest. Writing a function is the easy part. Turning it into a robust, callable service is where the complexity lies. A typical serverless deployment workflow might involve:

1. Writing the Core Logic: The C# or TypeScript function that qualifies a lead, processes a payment, or generates a report.
2. Wrapping in an HTTP Framework: Adding Express.js, Fastify, or a similar framework to handle HTTP requests and responses.
3. Implementing Input Validation: Writing manual checks or using a library like Zod or Joi to ensure incoming data is correct.
4. Containerizing the Application: Creating a Dockerfile to package the application and its dependencies.
5. Configuring Infrastructure: Setting up AWS Lambda, Google Cloud Functions, or a Kubernetes cluster, along with an API Gateway.
6. Managing Deployment: Building a CI/CD pipeline to deploy, version, and roll back changes.

Every step adds another layer of abstraction and another potential point of failure. You end up spending more time on the plumbing than on the application itself.

The Functions.do Approach: Agentic Workflows as Code

Functions.do fundamentally changes this dynamic. We’re not just another FaaS provider; we are an agentic workflow platform designed to turn your code into intelligent, durable software services. Our SDK is the bridge that makes this possible, abstracting away the underlying complexity.

The core idea is Business-as-Code. Your functions aren't just stateless scripts; they are versioned, typesafe "agents" that you can execute and compose through a simple API.

Let's see it in action. Imagine you need to score a sales lead based on a few data points.

import { Function } from 'functions.do';

// Define the input type for your function
// This ensures data integrity from end to end.
interface Lead {
  companySize: number;
  industry: string;
  hasBudget: boolean;
}

// Create a function agent on the Functions.do platform.
// 'score-lead-v1' is a unique, versioned identifier for this service.
const scoreLead = Function<Lead>('score-lead-v1');

// Execute the function with fully typesafe inputs.
// Your IDE and our platform will enforce this contract.
const { score, reason } = await scoreLead({
  companySize: 250,
  industry: 'SaaS',
  hasBudget: true,
});

console.log(`Lead Score: ${score}/100 - ${reason}`);

What just happened here?

1. Typesafe by Design: By defining the Lead interface, you create a contract. Our platform uses this to automatically validate inputs and guarantee the shape of the output. No more manual validation boilerplate.
2. Instant API Creation: The line Function<Lead>('score-lead-v1') doesn't just reference local code. It interfaces with a deployed service on the Functions.do platform. When you deploy your function, we automatically expose it as a secure, scalable API endpoint.
3. Zero Infrastructure: Notice what's missing? There’s no Express server, no Dockerfile, and no API Gateway configuration. You wrote pure business logic, and our platform turned it into a reliable service.

Beyond a Single Function: Building a True Workflow

The real power of Functions.do is revealed when you build agentic workflows. A single function is useful, but most business processes involve multiple steps.

With Functions.do, you can chain these agents together to create sophisticated, multi-step processes. Our platform manages the state, execution order, and error handling between each step.

For example, your scoreLead function could be the start of a larger workflow:

1. Score Lead: A new lead comes in and is scored by score-lead-v1.
2. Qualify and Assign: If the score is above 80, a second function, assign-to-rep-v1, is triggered to find and assign the best sales representative.
3. Notify Team: A third function, send-slack-alert-v1, sends a message to the #new-leads channel with the lead details.

Composing this on our platform is as simple as calling one function from another. We handle the orchestration, allowing you to build complex systems with simple, decoupled code.

Why Choose the Functions.do SDK?

• Focus on Your Business Logic: Stop writing boilerplate. Spend your time on the code that creates a competitive advantage.
• Ship with Confidence: End-to-end typesafety catches errors before they reach production, ensuring data integrity across your services.
• Eliminate Infrastructure Tax: We manage the servers, scaling, security, and deployments. You just push your code.
• Build Powerful Agentic Workflows: Go beyond simple serverless functions. Model entire business processes as composable, code-driven workflows.

Get Started Today

The paradigm of serverless computing promised to free developers from managing servers. Functions.do delivers on that promise by providing a truly code-driven workflow for building and shipping reliable, typesafe functions as robust services.

Ready to stop shipping infrastructure and start shipping value?

Explore the Functions.do Documentation and start building your first agentic workflow in minutes.