ServicesWorkProcessStudioContactStart a project →
← All projects

// DevOps · Fintech · Infrastructure

AlejandroFX

Digital ecosystem and tech platform for a trading community: product, infrastructure and 24/7 operations.

EngineeringInfrastructureGitOpsKubernetesObservability
Category
DevOps · Fintech · Infrastructure
Year
2026
Disciplines
Engineering · Infrastructure
Infra live · 24/7
argocd · sync
→ kubectl apply -k ./trading✓ deployment/copy-engine synced✓ deployment/signals-api healthy↻ hpa scaling 3 → 5 pods✓ grafana: latency p95 0.42s✓ rollout complete · 0 downtime
Continuous deployment · the cluster converges on its own after every commit

// Overview

Business → Product → Infrastructure → Operations.

AlejandroFX is the platform and digital ecosystem of a trading brand with a community of more than 1,500 traders. The project spans the website and product experience, the copy trading system and all the cloud infrastructure that keeps it running around the clock.

// The problem

A growing community running on manual hosting.

Trading real-time signals demands that nothing goes down. With manual deployments and no observability, every change was a risk and every incident a blind investigation.

0visibility
No observability
No metrics, centralized logs or alerts: problems were discovered through user reports.
Manualdeploys
Fragile deployments
Changes applied by hand, with no traceability and no reliable way to roll back.
1,500+traders
Growing scale
The community's growth made hand-built infrastructure unsustainable.

// Solution

Declarative infrastructure and observable operations.

We moved everything to Kubernetes with GitOps: every change is versioned in Git and deployed automatically. On top of that, a low-latency copy trading system and a full observability stack.

Kubernetes
Containerized workloads, autoscaling and reproducible deployments per environment.
GitOps · ArgoCD
Git as the single source of truth; instant rollback to any previous state.
Copy trading
Trade replication engine with sub-second latency.
Observability
Metrics, logs and alerts to see the system's true health in real time.

// Infrastructure

The architecture, top to bottom.

Each layer has a clear responsibility and is deployed independently.

01
Users
Community traders · web and mobile
WebsiteMembers area
↓
02
Application
Ecosystem frontend and product area
Next.js
↓
03
Services
Copy trading engine · signals API · jobs
Copy engineSignals API
↓
04
Kubernetes
Orchestration, autoscaling and separate environments
DeploymentsHPAEnvironments
↓
05
Infrastructure
Cloud, networking, secrets and declarative continuous delivery
GitOps · ArgoCDCI/CDSecrets
Architecture diagram: GitOps with ArgoCD, TLS ingress, autoscaled Kubernetes workloads, PostgreSQL and Redis, and an observability layer with Prometheus, Grafana and Loki.

// Copy Trading

Replicating a trade before the market moves.

Copy trading is a timing problem: if the copy arrives late, the price has already changed. The system listens to the lead trader's order and replicates it across subscribed accounts with minimal latency, keeping state consistent.

  • Ingestion of the lead trader's signal
  • Per-account validation and risk control
  • Concurrent replication across subscribed accounts
  • State confirmation and reconciliation
  • Tracking interface for the user
Copy trading flow: the master account's order goes through the signal bus and the risk filter before being replicated to follower accounts in under a second.

// GitOps · CI/CD

Every change, versioned and reversible.

The repository describes the system's desired state. ArgoCD applies it and keeps it in sync.

01
Commit
The infrastructure or service change is versioned in Git.
02
Pipeline
CI builds, tests and publishes the image.
03
Sync
ArgoCD detects the drift and reconciles the cluster.
04
Rollback
Rolling back means pointing to a previous commit, not a manual intervention.
ArgoCD sync status: the cluster's six applications synced with Git and healthy.

// Observability

See the system, don't guess it.

Metrics, logs and alerts wired into dashboards the team reviews every day.

Monitoring
Real-time health of pods, services and nodes.
Prometheus
Metrics
Latency, throughput, errors and saturation per service.
Grafana
Logs
Centralized logs, queryable by service and environment.
Centralized
Alerts
Actionable threshold-based alerts, before users report anything.
Alerting
Monitoring dashboard showing 99.94% uptime, 0.42 s p95 latency, ready pods and the 24-hour latency curve by percentile.

// Process

From manual hosting to an operable platform.

The migration couldn't interrupt service: the community trades real-time signals. We went layer by layer, validating each one before moving on to the next.

01
Discovery
Technical audit
We mapped what was actually running, how it was deployed and where the points of failure were.
  • Inventory of services and dependencies
  • Identification of single points of failure
  • Definition of availability targets
02
Design
Architecture
Layered platform design and a continuous delivery strategy.
  • Users → App → Services → K8s architecture
  • Environment separation
  • Copy trading engine model
03
Development
Infra & DevOps
Cluster setup, service containerization and GitOps as the only deployment path.
  • Kubernetes: deployments, HPA, resources
  • GitOps with ArgoCD and CI/CD pipelines
  • Low-latency copy trading engine
04
Operations
24/7
Observability in place: the team went from hearing about issues in reports to seeing them on a dashboard.
  • Metrics, logs and alerts wired up
  • System health dashboards
  • Actionable thresholds and alerts

// Gallery

What the platform looks like in operation.

Ecosystem interfaces, cluster status and monitoring dashboards.

AlejandroFx landing page with access to the mentorships and the waitlist.
AlejandroFx Proyecto Algoritmo page with the program's dates, duration and price.
ArgoCD resource tree: from the Application to the Deployment, the ReplicaSet, the five running pods and the autoscaler.
Dashboards for signals API throughput in requests per minute and copy latency by percentile.

// Our work

What IDEASCOL built on this project.

A primarily engineering project: architecture, infrastructure, continuous delivery and operations.

Architecture
  • Layered platform architecture design
  • Environment definition and deployment strategy
  • Modeling of the copy trading system flow
Infrastructure
  • Infrastructure setup on Kubernetes
  • Configuration of deployments, autoscaling and resources
  • Secrets management and environment separation
DevOps
  • GitOps implementation with ArgoCD
  • CI/CD pipelines and deployment automation
  • Rollback strategy and zero-downtime deployments
Operations
  • Observability stack: metrics, logs and alerts
  • System health dashboards
  • Definition of thresholds and actionable alerts

// Stack

What it's built with.

KubernetesGitOps · ArgoCDCI/CDPrometheusGrafanaCopy TradingNext.js

// Results

What changed once it went live.

99.9%
target uptime
0.42 s
p95 latency
<1 s
copy latency
1,500+
traders supported
  • Reproducible, zero-downtime deployments.
  • Instant rollback for any incident.
  • The team sees system health in real time.

// Build your future

Want to build something like this?

Tell us what you have in mind. We reply in under 24 hours with a first plan — no commitment, no jargon.