← Back to Projects
This project is a sub-project of BSDFlow
Entities
Mentored by: Kaltura
Entities - A multi-tenant, dynamic management system for entities, events, workflows, and real-time operations.
React
NestJS
.NET Core
Kafka
PostgreSQL
Redis
WebSocket
SignalR
Microservices
LLM Integration
Description
Entities sub-project of BSDFlow. A full-scale microservices-based management platform supporting dynamic entities, groups, processes, and events. Includes multi-tenant table architecture, generic Kafka handlers with correlation-based async RPC, Redis caching for performance, real-time updates via WebSocket & SignalR, integration with LLMs, Excel watchers, advanced validation using Strategy Pattern, RBAC permissions, GIS mapping, smart search with PostgreSQL FTS+GIN+Trigrams, and a complete load-testing engine. Enables organizations to define custom workflows, attach documents, track participants, and manage system-wide behaviors across distributed services.
Team Members
Cohort: Backend Bootcamp 2025 (Backend)
Responsibilities:
Developed an advanced Middleware in Node.js with full GraphQL support.
Built an automated logging system in .NET, including a dedicated REST API Middleware for full request tracing.
Added a new end-to-end entity, across: Frontend – React Middleware – Node.js Message Queue – Kafka Backend – .NET Database – PostgreSQL Including full integration flows across all system layers.
Implemented end-to-end entity update flow using the same stack (React + Node.js + Kafka + .NET + PostgreSQL) with full integration processes.
Added AI capabilities to support free-text queries, integrating with Google Gemini LLM.
Designed a concept for an installable .NET Desktop application for processing full Excel tables, running as a Background Service on the .NET host; includes an initial implementation for importing entire Excel sheets into the database.
Developed a dedicated REST service for the Documentation team and exposed it via REST API.
Managed system-wide integration with multiple teams to ensure alignment and cross-team consistency.
Operated the entire system using Docker containers, orchestrated with Docker Compose, within a full Microservices architecture.
...and more contributions not listed here
Responsibilities:
Designed and implemented the core infrastructure for dynamic entity storage, supporting user-defined schemas while optimizing the PostgreSQL database structure for efficient querying and scalability.
Developed robust microservices using C# and ASP.NET Core to process Kafka events, implementing a resilient event-driven architecture that supports asynchronous communication between different teams' components.
Built a scalable middleware layer using Node.js and NestJS that bridges the React frontend with the Kafka backend, featuring a custom Request/Reply flow mechanism with Promise mapping and correlation IDs to handle
mplemented a comprehensive end-to-end Authentication system using JWT (JSON Web Tokens), managing the login flow across React, Node.js, and .NET layers while ensuring secure secret management within the Docker environment.
Created a generic and dynamic React frontend infrastructure used by all teams, including a flexible manager dashboard for manipulating entity structures and a "Soft Delete" mechanism with immediate UI updates.
Orchestrated the development environment using Docker and Docker Compose, creating individual Dockerfiles for each microservice to ensure a consistent, isolated, and efficient development workflow for the entire team.
...and more contributions not listed here
Responsibilities:
Designed and set up the multi-layer backend architecture with PostgreSQL integration.
Developed a dynamic engine to create database tables from JSON schemas with constraints, relationships, and join tables.
Built a “group-level” entity management system, linking entities dynamically with flexible relationship types and selective record associations.
• Implemented a generic JSON-based validation mechanism for field-level rules.
Created smart record retrieval with pagination, relational joins, Redis caching, and real-time updates.
Enabled real-time UI updates via SignalR/WebSocket for selected groups.
Integrated frontend via gateway, GraphQL, and Kafka for seamless communication across layers.
Set up Dockerfiles for each layer and a unified Docker Compose environment for the team.
Migrated an existing Node.js project to a fully structured NestJS architecture.
...and more contributions not listed here
T
No preview image
Responsibilities:
Designed and implemented the front-end infrastructure for all project teams, enabling shared UI components and unified development workflows.
Refactored the Kafka integration into a generic, reusable .NET service using the Strategy design pattern, improving scalability and reducing code duplication.
Implemented full end-to-end functionality for retrieving entities and table metadata, including API development, business logic, and UI integration.
Developed full end-to-end functionality for adding dynamic attributes to tables, supporting custom data structures and flexible schema expansion.
Added support for importing table data from Excel files and exporting existing tables back to Excel, including parsing, validation, and UI interactions.
Implemented comprehensive unit tests across backend services, improving system reliability and ensuring high-quality code coverage.
Built graphical reporting capabilities by designing a logging table in the database and integrating it into a dashboard for visual insights.
Set up and integrated a Redis server for caching, significantly improving performance for frequently accessed operations.
Integrated core features with external teams via the shared gateway, ensuring interoperability and seamless cross-team communication.
Research: Event-sourcing infrastructure with Kafka replay for system-state reconstruction.
...and more contributions not listed here