Torabi Honey
Production e-commerce platform built with Domain-Driven Design, Clean Architecture, and a hardened CI/CD pipeline.
TorabiHoney is a production e-commerce platform for selling honey and related products, built solo with Domain-Driven Design and Clean Architecture across a .NET backend and a Next.js storefront and admin panel. It combines a Persian-optimized full-text search engine, a multi-channel notification system spanning email, SMS, and Telegram, a local ZarinPal payment integration, and a hardened container pipeline that separates automatic image publishing from a manually gated production deploy.
Visit WebsiteProducts
Domain Aggregates
Notification Delivery
Search Updates
Project Timeline
Project Started
Started designing the project's architecture and business domains.
Backend Development Completed
Completed the initial implementation of the backend and domain model.
Notification System Implemented
Implemented the multi-channel notification infrastructure and asynchronous processing mechanisms.
Background Processing Infrastructure
Designed and implemented dedicated background processing services for business operations.
Domain Model Refinement
Redesigned parts of the domain model to improve maintainability and performance characteristics.
REST API Completed
Completed the API layer including validation, versioning, and error handling mechanisms.
Frontend Development Completed
Completed the responsive and SEO-optimized frontend implementation.
Database Migration
Migrated the application's database infrastructure from SQL Server to PostgreSQL.
Search Infrastructure Redesign
Implemented a Persian-optimized full-text search solution with zero-downtime index updates.
Infrastructure Completion
Completed the Docker-based deployment infrastructure.
Testing and Improvements
Performed testing and addressed issues identified during pre-production deployment.
Production Deployment
Successfully deployed the project to the production environment.
Gated CI/CD Pipeline
Introduced a GitHub Actions pipeline that publishes SHA-pinned images to GHCR on every merge and gates production deployment behind a manual, rollback-capable workflow.
Payments, Bot, and Test Coverage
Shipped the ZarinPal payment gateway, the Telegram operations and customer bot, and an API-independent Playwright end-to-end suite for critical storefront and admin flows.
Project Overview
I started Torabi Honey in May 2024 as an independent side project to stay current with modern technologies and apply them in a real production system. The goal was not only to build an e-commerce platform but also to design maintainable, production-oriented software while balancing Domain-Driven Design, performance, infrastructure cost, and operational simplicity. During development, the architecture evolved through multiple domain refinements, a migration from SQL Server to PostgreSQL, a Persian-optimized full-text search solution, and reliable asynchronous processing for notifications and background operations. The most recent phase of the project focused on hardening what was already in production: a ZarinPal payment integration for real Iranian checkout flows, a Telegram bot that doubles as both an operational alerting channel and a customer notification channel, an API-independent Playwright test suite, and a CI/CD pipeline that deliberately separates automatic image publishing from a manually approved production deploy.
My Responsibilities
Key Features
Multi-Channel Notification System
A production notification system spanning email, SMS, and Telegram, with delivery tracking, retries, templates, and asynchronous processing built on Domain Events and the Outbox Pattern.
Telegram Operations & Customer Bot
A Telegram bot with two roles: it reports operational failures (failed deliveries, unhealthy dependencies, unhandled exceptions) with deduplication, and it serves as a first-class notification channel customers can link to their account via a one-time deep link.
ZarinPal Payment Integration
A complete Iranian payment flow built around ZarinPal — request, verification, and callback handling — reconciled with order and payment aggregate state.
Persian Full-Text Search
A Lucene.NET-powered, Persian-optimized search solution supporting full-text search, filtering, pagination, sorting, and zero-downtime index updates with result caching.
Background Processing Infrastructure
A dedicated background processing layer responsible for notifications, search indexing, discount management, and order lifecycle operations.
Domain-Driven Design Architecture
A domain model of 17 aggregates covering catalog, cart, orders, payments, discounts, reviews, users, risk scoring, and notifications, designed around business rules rather than persistence convenience.
Gated CI/CD Pipeline
GitHub Actions builds and publishes SHA-pinned container images to GHCR on every merge, while production deployment stays a separate, manually triggered step with rollback to any previously published image.
Technical Challenges
Balancing Domain-Driven Design with Performance Requirements
Designing a domain model that satisfies business requirements while balancing DDD principles, EF Core limitations, application performance, and long-term maintainability required multiple redesign iterations throughout the project.
Building Reliable Asynchronous Notification Processing
Ensuring reliable notification delivery across email, SMS, and Telegram introduced challenges around consistency, delivery tracking, retry mechanisms, and coordinating asynchronous operations with persisted data.
Designing a Cost-Effective Search Infrastructure
Building a Persian-optimized full-text search solution required balancing performance, infrastructure costs, language-specific requirements, and operational simplicity without relying on heavyweight search infrastructures.
Integrating a Local Payment Gateway Safely
Wiring ZarinPal into the order lifecycle meant handling redirect-based verification, callback edge cases, and failure states without ever leaving an order or payment aggregate in an inconsistent state.
Shipping to Production Without a Safety Net
As a solo developer without a team to review every deploy, the project needed a deployment process that made mistakes hard by default rather than relying on discipline alone.
Implemented Solutions
Iterative Domain Model Refinement
The domain model was redesigned multiple times to improve aggregate boundaries, reduce unnecessary database interactions, and better align business requirements with architectural constraints.
Reliable Notification Delivery Mechanism
A notification delivery mechanism was designed using Domain Events, the Outbox Pattern, and background workers to provide asynchronous processing, delivery tracking, and retry capabilities across email, SMS, and Telegram.
Persian-Optimized Search Strategy
A dedicated search strategy was implemented using full-text indexing, search result caching, and zero-downtime index updates to provide efficient Persian language search capabilities while keeping infrastructure requirements modest.
Verified Payment State Machine
The payment flow treats ZarinPal's redirect and callback as untrusted input, re-verifying transaction state server-side before any order or payment aggregate transition is committed.
Deliberately Gated Deployment Pipeline
CI automatically publishes immutable, SHA-pinned images on every merge, but production deployment requires a separate manual workflow run — turning 'someone has to consciously decide to deploy' into the actual approval gate.
Technical Achievements
Production-Ready Software Architecture
Successfully designed and deployed a maintainable software architecture based on Domain-Driven Design principles and Clean Architecture for a production environment.
Reliable Background Processing System
Implemented a reliable background processing infrastructure capable of handling multi-channel notifications, search indexing operations, and time-based business processes asynchronously.
Zero-Downtime Search Index Updates
Designed a search indexing strategy that supports zero-downtime index updates without affecting application availability during reindexing operations.
End-to-End Payment and Deployment Safety
Shipped a verified ZarinPal payment flow and a manually gated, rollback-capable CI/CD pipeline, closing the two areas of the platform with the highest cost of failure.
Deterministic End-to-End Test Coverage
Built an API-independent Playwright suite covering critical storefront and admin flows, running against a deterministic local mock API in CI rather than the real backend.
System Architecture
Domain-Driven Design
The project is organized around business domains and aggregate boundaries to improve maintainability, scalability, and separation of concerns.
Asynchronous Processing Architecture
Domain Events, background workers, and asynchronous processing mechanisms are used to decouple business operations from time-consuming processes.
Notification & Bot Architecture
The notification subsystem uses the Outbox Pattern and dedicated background workers to deliver messages across email, SMS, and Telegram, with the Telegram bot doubling as an operational alerting channel.
Search Architecture
A dedicated full-text search architecture on Lucene.NET supports Persian language optimization, search result caching, and zero-downtime index updates.
Layered Application Design
The application follows Clean Architecture principles to maintain clear boundaries between business logic, infrastructure concerns, and presentation layers.
Infrastructure & Deployment
Containerized Deployment
The application is deployed using Docker and Docker Compose, with non-root execution, read-only filesystems, resource limits, and health checks on every production service.
Gated CI/CD on GitHub Actions
Pull requests run path-aware backend builds, frontend linting, and Playwright E2E tests; merges to main publish SHA-pinned images to GHCR automatically, while production deployment stays a separate, manually triggered workflow with rollback support.
Caching Infrastructure
Redis is utilized for caching frequently accessed data and improving search performance while reducing unnecessary processing overhead.
Background Processing Services
Dedicated background services are responsible for multi-channel notification delivery, search indexing operations, order lifecycle management, and time-based business workflows.
Production Monitoring & Alerting
Structured logging through Serilog and Seq is paired with a Telegram alerting channel that reports failed deliveries and unhealthy dependencies as they happen.
Quick Info
Founder & Full-Stack Developer
May 2024 – Present
Torabi Honey
Iran