TuranBilgi Platform: API, Microservices & Client Applications

(July 2025 - Present)

TuranBilgi is a modern, API-first, multi-client backend platform designed to support complex business workflows alongside high-performance real-time communication. The platform follows a microservices-oriented and event-driven architecture, enabling independent scaling, fault isolation, and long-term extensibility across backend services and client applications.

Platform Overview

TuranBilgi is designed as a unified backend system serving multiple client applications through a shared API layer. All business logic, authentication, authorization, and real-time capabilities are centralized within the platform, ensuring consistency across all consuming clients. The platform consists of two primary backend components:

1. Core Business API

The core API is implemented using Node.js (Express.js with TypeScript) and exposes both REST and GraphQL interfaces. It acts as the central business layer of the system and is responsible for domain workflows and transactional operations including:

User and administrator authentication and authorization
Account registration, login, and profile management
Idea pool management
Project and application handling
Contract management
Invoice generation and payment processing
Support ticket management
Commenting and reporting

The following infrastructure is used to handle data:

PostgreSQL is used as the primary relational database for business-critical and transactional data.
MongoDB is used for document-based, write-heavy, and schema-flexible data such as comments, reports, and audit logs.
Redis is used for caching, distributed coordination, and performance optimization.
RabbitMQ is used for asynchronous background jobs and external integrations (email and SMS notifications), ensuring non-blocking request handling and reliable message delivery.

2. Real-Time Chat, Notification & Presence Microservice

A dedicated NestJS + Socket.IO microservice handles all real-time communication concerns, including persistent WebSocket connections and event propagation. This service exposes REST and GraphQL APIs while maintaining persistent WebSocket connections for real-time features. Key capabilities include:

Real-time chat and messaging
Room-based communication and state synchronization
Notification delivery
User presence tracking
Audit logging (for all APIs or services)

To support horizontal scalability and distributed WebSocket gateways:

Apache Kafka is used as the event streaming backbone for chat and notification events. Kafka enables multiple gateway instances to publish and consume chat and notification events reliably across the cluster.
Redis plays a critical role in coordinating distributed socket events, tracking room membership, preventing duplicate message emissions, and synchronizing WebSocket gateways and distributed state.

This separation allows the real-time system to scale independently from the core business API while maintaining low latency and consistency.

Security & Authentication

All API or services use a shared JWT-based authentication model, enabling secure client-to-server and service-to-service communication to simplify identity propagation while maintaining clear trust boundaries between system components.

Testing & Quality Assurance

TuranBilgi adopts a comprehensive automated testing strategy using Jest to ensure correctness, reliability, and maintainability across the platform:

Unit tests for isolated business logic and services
Integration tests for validating interactions between APIs, databases, caches, and message brokers
End-to-End (E2E) tests for complete system flows across REST, GraphQL, and real-time WebSocket interfaces

This layered testing approach supports safe refactoring, reduces regression risk, and ensures consistent behavior in a distributed environment.

Containerization & Deployment

The entire ecosystem is containerized under the TuranDocker project. This includes Core Business API, Real-time microservices, PostgreSQL, MongoDB, Redis, Apache Kafka and RabbitMQ. This setup enables fast, repeatable deployments on any Linux VPS and provides a strong foundation for future orchestration with Kubernetes or other container platforms, while remaining fully operational with Docker Compose or Docker Swarm.

Architectural Focus

TuranBilgi emphasizes:

API-first design (REST & GraphQL)
Event-driven communication
Horizontal scalability
Fault isolation via microservices
Polyglot persistence
Real-time system reliability
Clean separation of concerns

The platform is designed to evolve, allowing additional services, clients (web, mobile, desktop), and integrations to be added without architectural rewrites.

Client Applications

TuranBilgi is a multi-client platform, designed to serve different user experiences through a shared backend infrastructure. Client applications include:

Admin Panel, to be built with Vite + React, for internal system management and operational workflows
End-user Web Application, to be built with Next.js (React), providing interactive and SEO-friendly user experiences
End-user Mobile Application, to be built with React Native, enabling cross-platform mobile access
Public Website, to be built with Next.js (React), focused on marketing and informational content

All client applications consume the same TuranBilgi APIs (REST, GraphQL, and WebSockets), ensuring:

Shared authentication and authorization
Consistent business logic
Unified real-time behavior across web, mobile, and desktop platforms