← All work

(SaaS · Serverless platform · 2025)

Dart Cloud Functions

Aortem's serverless platform for backend logic written in Dart. Flutter teams write functions in the language they already use and deploy without managing servers, containers or a second language.

(Role)
Lead Product Designer, Aortem
(Timeline)
Feb – Apr 2025
(Platform)
Web console and CLI
(Tools)
Figma, FigJam
Dart Cloud Functions case-study cover: “Run code at scale. No servers to manage.” beside the dashboard, the create-function flow and a Dart code sample

[01]

Context & problem.

Dart Cloud Functions sits inside Aortem's Dart-native ecosystem beside IntelliToggle and TechniDox. The console mirrors the CLI's language, because most deploys start in a terminal.

Flutter developers can build a whole app in Dart, then hit a wall the moment they need a backend. Serverless platforms centre on JavaScript, Python and Go, so Dart teams rewrite logic in another language, duplicate their data models, or hand-build containers.

How might we let a Flutter developer go from a Dart function on their laptop to a live, observable endpoint, without leaving Dart or learning infrastructure?

[02]

Who it’s for.

Flutter developers who need backend logic, and the teams who operate and monitor it.

[03]

Goals.

One language, end to end

  • Write, test and deploy functions in Dart
  • Share types and validation between app and function

Deploy in one step

  • One CLI command or console action from code to live URL
  • Sensible defaults, editable later

See what is happening

  • Logs, invocations, errors and latency per function
  • Deploy status in plain language: building, live, failed, and why

Make changes safe

  • Versioned deployments with one-click rollback
  • Secrets managed per environment

[04]

Structure & flow.

(Core journey)

  1. Install CLI
  2. Log in
  3. Create project
  4. Pick a template
  5. Write handler
  6. Test locally
  7. Deploy
  8. Get live URL
  9. Add secrets
  10. Monitor
  11. Roll back or iterate

[05]

Design decisions.

  1. Decision 01

    Deploy status people can trust

    (Problem)
    A spinner during deploy leaves people unsure anything is happening.
    (Response)
    Staged progress (Packaging, Building, Starting, Live) in both CLI and console, ending with the live URL and a test command.
  2. Decision 02

    From error to cause

    (Problem)
    Raw stack traces in a log stream turn a failure into a search.
    (Response)
    Errors grouped with count, first and last seen, the failing request and a plain-language summary above the trace.
  3. Decision 03

    Secrets by environment

    (Problem)
    It is easy to lose track of which environment a secret applies to.
    (Response)
    A secrets-by-environment matrix with masked values, and environment badges everywhere a secret is used.

[06]

The solution.

  • Functions overview

    Every function with status, trigger type, invocations, error rate and p95 latency.

  • Function detail

    Live URL and a copy-ready test command up top; invocation, error and latency charts; recent logs below.

  • Deploy experience

    Staged progress, readable failure reasons and a link to the exact log line.

  • Versions and rollback

    A timeline of deployments with who shipped what, and one click to restore.

[07]

What I learned.

  • Design the CLI as seriously as the screen.

    For developers, the terminal is usually the first interface.

  • Status beats speed.

    A clearly staged deploy feels faster than an unexplained wait.

  • Errors are a UX surface.

    Grouping and plain-language summaries turn panic into a next step.

(Full case study)

Research, process and every screen are in the complete case study on Behance.

View on Behance

(Next project)

TechniDox