Bulk Email & SMS Automation Platform Development

The Bulk Email & SMS Automation Platform is a system built to help organizations streamline communication with their users by enabling automated bulk messaging via email and SMS. Developed using Go (Golang) for the backend and React + TypeScript for the frontend, the platform significantly reduces manual operations and enhances automation, resulting in a 40% reduction in human effort and a 20% increase in system performance and efficiency.

The platform leverages gRPC and gRPC-Web for high-performance communication between the backend services and the React frontend, ensuring faster and more reliable data exchange compared to traditional REST APIs. Deployed with Docker, Nginx, and Envoy, the system provides scalability, fault tolerance, and seamless CI/CD automation.

Before this system, sending large volumes of emails or SMS messages required manual input or third-party services that lacked flexibility and visibility. The main challenges included:

Inefficient bulk message delivery processes.

Limited control over messaging templates and history.

Lack of monitoring tools for message balance and delivery reports.

Performance bottlenecks with traditional REST APIs during heavy loads.

To address these challenges, the system was built as a distributed, event-driven messaging platform with a strong focus on scalability, automation, and reliability.

Supports sending thousands of emails and SMS messages simultaneously via excel file upload.

Integrates with third-party SMS gateways and email providers.

Ensures high deliverability and retry mechanisms for failed messages.

Admins can design and store reusable email and SMS templates with dynamic variables (e.g., name, account info).

Templates can be versioned and categorized for marketing, transactional, or alert notifications.

WYSIWYG editor for easy customization and preview before sending.

Integrated SMS balance tracking system that fetches current credits from the SMS provider’s API.

Automatic alerts when SMS balance is low.

Backend services communicate via gRPC, improving response speed and reducing payload size.

gRPC-Web used to enable secure, efficient communication between the React frontend and Go backend through Envoy proxy.

Binary serialization with Protocol Buffers (protobuf) ensures faster data exchange than JSON.

Automated pipelines for building, testing, and deploying both backend and frontend.

On each commit:

Each service (backend, frontend, envoy, nginx) containerized for modularity and scalability.

Envoy Proxy handles gRPC-Web traffic and load balancing across microservices.

Nginx acts as the reverse proxy for static content and SSL termination.

Combined architecture ensures high throughput, fault isolation, and low latency.

React (TypeScript) → gRPC-Web → Envoy Proxy → Go gRPC Backend → MySQL Database

Docker containers for isolated services

Nginx for SSL termination and routing

Envoy for gRPC and load balancing

GitHub Actions for CI/CD automation

Frontend: React + TypeScript + gRPC-Web

Backend: Go (Golang) + gRPC + Protocol Buffers

Database: MySQL

Containerization: Docker

Proxy Servers: Envoy + Nginx

CI/CD: GitHub Actions

Reduced manual communication workload by 40%.

Increased delivery performance and reliability by 20%.

Achieved real-time feedback on delivery status and SMS balance.

Improved developer productivity with automated CI/CD pipelines and containerized environments.

Achieved sub-second latency with gRPC and Envoy, optimizing network performance.

Designed and implemented the Go gRPC backend architecture.

Developed protocol buffer schemas for message exchange between services.

Integrated email and SMS APIs for automated delivery and balance checking.

Built the template creation and approval modules.

Set up Docker, Envoy, and Nginx for production deployment.

Configured GitHub Actions pipelines for continuous integration and deployment.

Deployed the full system to AWS EC2.