Tendex — Investment Platform for the Digital Assets Market

The existing platform interface was outdated, inconvenient for investors, and did not reflect the status of a regulated Swiss fund. It was necessary to renew the visual part and UX without losing functionality and without disrupting ongoing business processes.

• Audited the existing Twig templates and identified reusable components.
• Developed a new design system: grid, typography, UI components.
• Reimplemented key pages with Twig and integrated Vue components for interactive areas (charts, tables, forms).
• Ensured responsiveness and correct rendering on mobile devices.

Investors or administrators needed to be able to terminate an investment plan early, with correct recalculation of returns, fees, and refunds. Data desynchronization during parallel operations had to be avoided.

• Designed a domain model for plan termination covering all states (active, frozen, queued).
• Implemented a service for calculating final returns and fees.
• Moved heavy operations into asynchronous tasks via RabbitMQ.
• Added idempotency of operations and locking via Redis.

Simple user deletion broke related entities (investment plans, transactions, referrals). A safe deletion mechanism was needed that preserves financial history and regulatory requirements.

• Introduced a soft-delete mechanism for users while preserving relations.
• Designed cascade processing: anonymization of personal data, preservation of transaction history.
• Implemented a background task for cleaning up related entities via RabbitMQ.
• Added logging and auditing of deletion operations.

Investors needed the ability to temporarily pause return accrual on a plan without closing it — for example, during market instability. Such periods had to be correctly accounted for in calculations.

• Added the "frozen" state to the investment plan lifecycle.
• Implemented the logic for pausing accruals and correct resumption.
• Updated return calculation to account for freezing periods.
• Added notifications to the investor about the plan status.

Investors wanted to create a plan in advance with automatic launch on a specified date. Reliable task scheduling was required, robust against failures and service restarts.

• Implemented delayed start via the Symfony scheduler + RabbitMQ delayed messages.
• Added idempotent start processing (protection against double start).
• Provided monitoring of delayed tasks and logging.
• Implemented notifications to the investor about the start.

The referral system required flexibility: administrators needed to be able to change referral assignments, and investors needed to see the current structure. The existing implementation did not allow editing assignments without losing accrual history.

• Designed a referral relationship model with versioning.
• Implemented an editing interface for referrals for administrators.
• Preserved accrual history when assignments change.
• Added validation against cyclic dependencies.

Growing load and the number of operations (accruals, plan start/stop, notifications) required moving heavy operations out of the synchronous HTTP cycle so as not to block user requests.

• Designed an event queue for key domain operations.
• Implemented workers using Symfony Messenger + RabbitMQ.
• Added retry policies, a dead-letter queue, and monitoring.
• Ensured idempotency of handlers.

Fast search across large volumes of data (transactions, plans, users) and building analytics required a specialized search engine instead of heavy SQL queries.

• Configured ElasticSearch indices for key entities.
• Implemented data synchronization via RabbitMQ events.
• Added search queries with filters and aggregations for analytics.
• Optimized mappings and reindexing.

High frequency of access to frequently used data and the need for protection against race conditions during parallel operations required a reliable cache and locking mechanism.

• Introduced caching of hot data and aggregates in Redis.
• Implemented distributed locks for critical operations (plan start/termination).
• Configured cache invalidation via events.
• Added monitoring of hit/miss and response times.

A regulated fund requires a complete audit of all financial operations: who, when, what, and on what basis. An audit system had to be built that does not slow down core processes.

• Designed an audit log schema linked to user, plan, and transaction.
• Implemented asynchronous audit writing via RabbitMQ.
• Added tools for searching and exporting audit logs for administrators (ElasticSearch).
• Ensured immutability of records.

The investment platform operates 24/7, and any delay in event processing or worker failure is critical. A system for monitoring key metrics and alerts was required.

• Set up collection of metrics for queues (RabbitMQ), Redis, ElasticSearch, and key business events.
• Implemented alerts for anomalies (DLQ growth, delays, worker errors).
• Added dashboards for the team.
• Integrated logging of critical operations.