Consolidating Serverless: Migrating a Multi-Service Cloud Architecture to Fullstack Dart

Let’s look at how to shrink a sprawling, multi-container serverless footprint down into a single, type-safe Dart backend function to slash cloud costs.

What you'll learn

• Why managing dozens of micro-functions spikes your idle infrastructure bills.
• How to structure shared domain models for pure-Dart server and client environments.
• Using Freezed DTOs to route multiple inner actions through a single serverless endpoint.
• Enforcing strict access control lists (ACLs) directly in your business logic.

The Cost Trap of Multi-Service Serverless

When building rapidly, it's easy to spin up dozens of isolated cloud functions. Each endpoint naturally turns into its own dedicated Cloud Run service behind the scenes.

While these services scale down to zero when idle, production realities often force you to set minimum instance counts to avoid cold starts. Multiply that baseline by 15 separate services, and your hosting bill climbs even when traffic flatlines.

// Old setup: 15 separate Node.js Cloud Run services
// Each maintains its own minimum instance count, draining your budget.
exports.saveOrder = functions.https.onRequest(async (req, res) => {
  // Handle order creation
});

exports.completeOrder = functions.https.onRequest(async (req, res) => {
  // Handle order completion
});

Speed Note: Consolidating your server-side logic into a single entry point eliminates redundant cold-start overhead and drastically simplifies your deployment pipelines.

Sharing Models Without Flutter Dependencies

True fullstack type safety requires sharing domain models between your mobile/web client and your server. However, your server-side code must remain pure Dart, free of any dependencies on the Flutter SDK.

Break out your core data layer into an independent package, and swap client-heavy Firestore dependencies for pure-Dart admin packages.

// pkg:data_layer/lib/src/models/latte_order.dart
import 'package:freezed_annotation/freezed_annotation.dart';

part 'latte_order.freezed.dart';
part 'latte_order.g.dart';

@freezed
sealed class LatteOrder with _$LatteOrder {
  const factory LatteOrder({
    required String id,
    required String customerName,
    required String drinkType,
    required bool isCompleted,
  }) = _LatteOrder;

  factory LatteOrder.fromJson(Map<String, dynamic> json) =>
      _$LatteOrderFromJson(json);
}

Gotcha: Never import package:flutter or client-side Firebase packages in your core data package, or your server deployment will immediately fail compilation.

Routing Multiple Actions Through a Single Endpoint

To funnel all traffic through one server-side function without losing type safety, introduce a parent DTO interface (BackendMessage). Use Freezed to map distinct message parameters to their corresponding response types.

This pattern acts like a lightweight RPC router inside a single serverless function container.

import 'package:freezed_annotation/freezed_annotation.dart';

part 'message_parameters.freezed.dart';

abstract interface class BackendMessage<R> {
  Map<String, dynamic> toJson();
}

@freezed
sealed class MessageParameters with _$MessageParameters {
  @Implements.fromString('BackendMessage<SaveOrderResponse>')
  const factory MessageParameters.saveOrder({
    required LatteOrder order,
  }) = SaveOrderParameters;

  @Implements.fromString('BackendMessage<EmptyResponse>')
  const factory MessageParameters.completeOrder({
    required String orderId,
  }) = CompleteOrderParameters;
}

Writing the Unified HTTPS Handler

With your message protocol defined, you can now write a single Firebase HTTPS callable function. Use a Dart switch expression on the incoming request payload to cleanly dispatch execution to your domain functions.

This approach keeps your cloud bill minimal because only one container instance handles incoming RPC payloads.

import 'package:firebase_functions_interop/firebase_functions_interop.dart' as firebase;

void main() {
  firebase.https.onCallWithData<MessageParameters, Object>((request) async {
    final response = switch (request.data) {
      SaveOrderParameters msg => await _handleSaveOrder(msg),
      CompleteOrderParameters msg => await _handleCompleteOrder(msg),
    };
    
    return response.toJson();
  });
}

Future<SaveOrderResponse> _handleSaveOrder(SaveOrderParameters params) async {
  // Execute database mutation and business logic here
  return SaveOrderResponse(latteOrder: params.order);
}

Future<EmptyResponse> _handleCompleteOrder(CompleteOrderParameters params) async {
  // Execute completion logic
  return const MessageResponse.empty();
}

Security Tip: Lock down your database security rules to block all direct client-side writes. Force every mutation to flow exclusively through your unified callable function where validation and ACLs run.

Summary

Migrating your backend from a sprawling set of micro-functions to a consolidated fullstack Dart architecture delivers massive dividends. You get end-to-end type safety across your codebase, eliminate redundant server overhead, and drastically reduce cloud hosting costs—all while keeping your business logic clean and testable.

Next Steps

• Extract your data models into a standalone, Flutter-agnostic package.
• Define your payload router using Freezed sealed classes for robust payload validation.
• Update your security rules to route all database mutations through your new single-endpoint backend.