Nick Stoddart Consulting Logo
Nick Stoddart Consulting
ChatServicesBlogEngage
Schedule Consultation

Function-as-a-Service (FaaS): Tiny Functions, Giant Leaps

May 29, 2025

Function-as-a-Service (FaaS): Tiny Functions, Giant Leaps

1. What is FaaS, in one breath?

Function-as-a-Service lets you deploy a single function—just the code for one job—without provisioning servers, containers, or runtimes. Upload the snippet, wire an event trigger (HTTP call, queue message, cron tick, etc.), and the cloud spins it up on demand, bills by the millisecond, and tears it down when idle.

2. Why the “small-change, big-impact” buzz?

FaaS trait Why it multiplies impact
Atomic Each function does one thing 🡒 easier to test, reason about, and replace.
Event-driven Hooks anywhere in the flow (checkout, data update, sensor ping) without altering the core app.
Auto-scaling Burst from zero to thousands of concurrent executions in seconds—no capacity meetings.
Pay-per-use No idle fleet to babysit, so even moon-shot experiments cost cents.
Language flexibility Polyglot: write fraud detection in Python, image resize in Go, webhook in Node—deploy side by side.

Result: A two-line function can unblock a revenue stream, patch a vulnerability, or prototype a new feature—fast.

3. Quick scenarios where a 20-line function moves the needle

  1. Edge personalization – Inject a “Hello {{firstName}}!” banner at CDN edge based on cookie; bump conversion by 2 %.
  2. Real-time fraud rule – Extra card checks only on high-risk SKUs; save $50 k/month in chargebacks.
  3. Data quality guardrail – Auto-quarantine malformed CSV rows before they poison the warehouse; analysts thank you.
  4. Legacy-to-modern bridge – When the mainframe emits a flat-file, a function converts it to JSON and drops it in Kafka—no big-bang rewrite.
  5. Feature-flag cleanup – Nightly cron function prunes stale toggles; keeps codebase lean.

4. How to weave FaaS into an existing architecture

  1. Start at the edges

    • APIs that spike unpredictably
    • Batch jobs that run < 10 minutes a day
    • One-off cron tasks migrated from a duct-tape VM

  2. Adopt “strangler-fig” evolution Carve a single endpoint or workflow out of the monolith into a function. Route traffic through a façade; slowly grow new functionality around the old core until the legacy piece withers away.

  3. Event mesh > point-to-point spaghetti Emit domain events (“OrderPlaced”, “InvoicePaid”), then subscribe with functions. Keeps coupling low; lets new teams add features without PR chains across the org.

  4. Automate the boring bits

    • CI/CD: Lint → test → package → deploy in under 2 minutes.
    • Observability: Wrap with structured logs + metrics (cold starts, duration).
    • Security: Sign artifacts; least-privilege IAM per function.

5. Common objections, defused

Concern Reality check
“Cold starts will kill latency.” Modern runtimes warm in ~100 ms; keep hot with min-instances or edge FaaS.
“Debugging distributed functions is a maze.” Treat each function like a micro-unit-test; aggregate logs/traces in one pane (OpenTelemetry, Honeycomb, etc.).
“Vendor lock-in!” Stick to vanilla language, emit/consume via HTTP or CloudEvents, and you can re-deploy to any major provider—or even on-prem FaaS platforms like OpenFaaS or Knative.
“Not cost-effective at scale.” True for steady 24/7 workloads—run those on containers/VMs. Use FaaS for bursty or experiment workloads where elasticity wins.

6. Tips for getting outsized ROI from tiny functions

  1. Think in events, not endpoints – Map key business moments; ask, “Could a 30-line handler add value here?”
  2. Bake in feature flags – Flip functionality on/off instantly; perfect for A/B experiments.
  3. Bundle shared libs smartly – Keep dependencies slim; share via internal packages or layers to avoid megabyte zips.
  4. Rotate newcomers through a “Function Friday” – Let engineers ship a measurable improvement in a day; culture booster.
  5. Measure everything – Track execution count, p95 latency, and dollar cost per 1 k runs; visibility drives confidence.

7. A sprint-sized adoption roadmap

Week Milestone
1 Pick one low-risk use-case (e.g., thumbnail generator).
2 Set up CI/CD pipeline + observability stack.
3 Deploy to production under a dark launch flag; monitor.
4 Expand to two more events; hold a retro on patterns, IAM, logging.
5-6 Document best practices; publish an “Internal FaaS Cookbook.”
7+ Encourage product squads to propose functions in each sprint planning.

8. Key takeaways

  • FaaS ≠ fad. It’s the logical next step after VMs and containers—compute that spawns only when needed.
  • Small ≠ trivial. A 15-second function can lift revenue, resilience, or developer morale.
  • Platform agnostic by design. Stick to open triggers and stateless patterns, and your code ports anywhere.
  • Start small, learn fast, expand wisely. The businesses that treat FaaS as an experimentation engine will reap the biggest gains.

Give a team one afternoon, a handful of events, and Function-as-a-Service, and you’ll be surprised how a “tiny” release can echo through the KPIs. The next big impact might be just one small function away.