Events

Development of a Dynamic Process Engine Designed and implemented a flexible workflow engine that enables each organization to define customized processes with dynamic fields stored in JSONB, including versioning, inheritance to events and participants, and a modular structure supporting future extensibility.

Implementation of the Events & Participants Architecture Developed a full system for managing events and participants, including complex relational models, linked documents, and dynamic form generation based on organizational process definitions.

Microservices Architecture with Kafka Communication Built a distributed Microservices architecture using Kafka for inter-service communication, including a Strategy-Pattern–based Message Dispatcher for efficient routing of messages to dedicated service handlers.

Development of an Asynchronous Validation Microservice Created a validation service responsible for real-time data and document validation — checking field types, required fields, and JSON structures — using an asynchronous Kafka Request/Reply mechanism.

Advanced Database Design (PostgreSQL + JSONB + RLS) Designed and maintained a complex PostgreSQL database using JSONB structures, SQL functions, triggers, multi-table relationships, and implemented Row-Level Security (RLS) to ensure secure tenant separation.

Development of an Advanced Load Testing System (C# .NET Microservice) Built an automated Load Testing microservice capable of running dynamic test scenarios, sending high-volume API requests, validating results via Smart Async Polling, and managing sequential execution using a Queue to prevent database conflicts.

Frontend Development in React with a Unified Modern UI Developed full React-based user interfaces for managing processes, events, documents, and participants, including dynamic forms, error handling, clean integration with backend APIs, and a consistent, modern design across the application.

Developed a dynamic process and event management system with PostgreSQL (JSONB) to handle customizable fields, enabling flexible workflows and dynamic schema updates. Utilized Kafka for real-time event handling and communication between microservices, deployed using Docker Compose for seamless integration.

Built backend microservices for data processing and validation using .NET 8 and NestJS (TypeScript).

Built REST APIs to expose authorized access to workflows and events, secured with JWT, ensuring proper user authentication and authorization

Developed a real-time entity and document linkage system using PostgreSQL and many-to-many relational tables, ensuring full traceability and auditing for event-related data.

Implemented a smart search mechanism using GIN indexing and Full Text Search (FTS) in PostgreSQL for fast, efficient data retrieval, even with typos or spelling mistakes. This system enables precise querying across large datasets.

Managing events and processes

Designed real-time features with WebSocket

Implemented RBAC for secure permission management and enforcement.

Implemented smart search using PostgreSQL GIN indexing and Full Text Search for fast and accurate data retrieval.

Used Kafka for event-driven communication between microservices

Built core backend services with .NET 8 and NestJS

Designed dynamic process execution using Factory Pattern.

Modeled flexible data structures using PostgreSQL with JSONB

Built REST APIs with authentication and authorization (JWT)

Set up a full development and deployment environment with Docker Compose, adhering to SOLID and Agile principles.

Developed the custom-fields mechanism of the Process entity, enabling fully dynamic workflows through a JSONB-based structure in PostgreSQL. Implemented the server-side logic and validation rules in .NET, built the REST API layer in NestJS, and created the data integration that allows each organization to define flexible and customizable processes.

Implemented the Strategy Design Pattern to create a Kafka Message Dispatcher for routing messages, where each topic is directed to its dedicated handler. This architecture enables clean separation between microservices and smooth system extensibility.

Developed a Load Testing mechanism in .NET to evaluate system performance under heavy load, including user-defined run counts, Smart Async Polling for DB-level result validation, and a queue-based execution flow to prevent parallel runs — all built in a modular and easily extensible architecture.

Implemented the feature for linking existing documents to events, enabling reuse of documents such as syllabi, presentations, and guidelines across multiple events.

Developed the capability to update custom-field values for an event participant, including validation logic and data persistence for the dynamic field structure, with a simple and user-friendly interface to perform the action.

The solution was implemented within an event-driven microservices architecture with Kafka-based communication, running in a Docker Compose environment. Applied best practices with Git and Unit Tests, and completed multiple code reviews.