System Architecture of Multi-Tenant IoT & Financial SaaS Platform

Overview

Designed and implemented a scalable, event-driven microservices architecture for a multi-organization IoT SaaS platform managing lithium-ion battery rentals, financial contracts, and operational workflows.

The system supports device lifecycle management, payment-gated access, loan and invoice automation, and real-time operational insights, while maintaining high availability, performance, and cost efficiency at scale.

Architecture Summary

Architecture Style: Microservices, event-driven
Communication: REST + asynchronous PUB/SUB (AWS SNS)
Deployment: Dockerized services on AWS ECS (Fargate)
Data Storage: DynamoDB (service-owned databases) + Data Warehouse
Asynchronous Processing: DynamoDB Streams + AWS Lambda
Multi-Tenancy: Organization-isolated access across all services

Internal Communication Model

Event-Driven Microservices

All microservices communicate using a PUB/SUB model via AWS SNS.

Services publish domain events (e.g., user update, battery update, payment event)
Subscribed services react asynchronously
Loose coupling improves scalability and fault isolation

Asynchronous Processing Strategy

DynamoDB Streams + AWS Lambda

Each service owns its DynamoDB tables
DynamoDB Streams trigger Lambda functions on data changes
Lambda functions perform background tasks such as:
- Updating related services’ data
- Processing financial logic
- Maintaining derived or aggregated data

This approach ensures:

Non-blocking request handling
Improved system responsiveness
Reliable background processing

Data Architecture

Operational Data:
- Stored in DynamoDB for fast, scalable access
- Each microservice owns its database (database-per-service pattern)
Historical & Analytical Data:
- Stored in a Data Warehouse
- Used for analytics, reporting, and performance insights

This separation prevents performance degradation as data volume grows and keeps the application responsive for active users.

AWS Infrastructure & Deployment

Compute & Orchestration

AWS ECS (Fargate) for containerized microservices
Low baseline configuration with auto-scaling enabled
Optimized for cost efficiency and traffic spikes
Service Configuration:

Networking & Security

AWS VPC & Subnets to isolate services
AWS ALB for request routing and load balancing
AWS-managed SSL certificates for secure communication

Monitoring & Observability

Amazon CloudWatch for:
- Centralized logging
- Metrics and anomaly detection
- Operational visibility across services

Infrastructure as Code

AWS CloudFormation used to define and deploy:
- ECS services
- Networking resources
- Auto-scaling policies
- Supporting AWS infrastructure

Key Design Outcomes

Highly scalable, loosely coupled microservices architecture
Cost-efficient infrastructure with auto-scaling ECS services
Improved performance by separating active and historical data
Reliable financial enforcement through event-driven workflows
Clear service ownership and fault isolation

Tech Stack

Python, Flask, Microservices, AWS ECS, DynamoDB, SNS, Lambda, CloudWatch, CloudFormation

👉 This architecture reflects my approach to designing systems that balance scalability, reliability, performance, and operational simplicity.