The Technology Behind Red Rock: How We Build and Why

At Red Rock, engineering is not a support function. It is the core infrastructure from which every system, every client delivery, and every institutional capability is built. In this post, our CTO breaks down the full technology stack behind Red Rock: the languages, frameworks, infrastructure, and principles that define how we build and why.

Programming Languages

TypeScript: Our Primary Language

TypeScript is the backbone of nearly everything we build. It extends JavaScript with a strong type system, which means our code is checked for errors before it ever runs. This gives us the speed of JavaScript development with the safety net of a compiled language.

We use TypeScript across both our backend services and frontend applications, which means our developers can move fluidly between the two. One language, one ecosystem, less context switching.

Solidity: For the Blockchain

Our smart contracts, the programs that run on the Ethereum blockchain, are written in Solidity. These contracts handle token creation, trading mechanics, and decentralized exchange integrations. Solidity is the industry standard for Ethereum development, and its ecosystem gives us access to battle-tested libraries like OpenZeppelin.

Go: For High-Performance CLI Tools

When we need lightweight, fast, and self-contained tools, we reach for Go. Our backup automation CLI and internal utilities are built in Go because it compiles to a single binary with no dependencies, easy to deploy, easy to run, anywhere.

Backend Development

NestJS: A Structured Foundation

All of our backend services are built on NestJS, a progressive Node.js framework that brings structure and discipline to server-side TypeScript. NestJS uses a modular architecture with dependency injection, a design pattern that makes our code testable, maintainable, and easy to extend.

Why NestJS over plain Express or Fastify? Because at our scale, with 8+ backend services running in production, consistency matters. NestJS gives every service the same structure, the same patterns, and the same conventions. A developer working on our chat service can jump into our payments API and feel right at home.

Microservices Architecture

We don't build monoliths. Each of our services owns a specific domain: user accounts, messaging, live streaming, blockchain indexing, and communicates with the others through events, not direct calls. This means one service can be updated, scaled, or restarted without affecting the rest.

Frontend Development

Next.js + React: For Web Applications

Our web dashboards, admin panels, company website, and blog are all built with Next.js, a React-based framework. Next.js gives us server-side rendering for fast initial page loads and great SEO, combined with the rich interactivity of React on the client side.

We pair it with Tailwind CSS for styling, a utility-first CSS framework that keeps our design system consistent and our stylesheets lean. For UI components, we use Radix UI, which provides accessible, unstyled primitives that we customize to match our design language.

Quasar + Vue.js: For Mobile

Our mobile application is built with Quasar Framework, powered by Vue.js. Quasar lets us write one codebase and ship it as a web app, an iOS app, and an Android app, all from the same source. Under the hood, Capacitor bridges the gap between web code and native device features like push notifications, camera access, and biometrics.

This approach lets a small team deliver a polished native experience on every platform without maintaining three separate codebases.

Databases & Data Storage

We use three database technologies, each chosen for the type of data it handles best.

PostgreSQL: The Workhorse

PostgreSQL is our primary database for structured, relational data, user profiles, transactions, blockchain records, and admin data. It is ACID-compliant, meaning every transaction is reliable and consistent, even under heavy load. We manage our database schemas through TypeORM, an Object-Relational Mapper that lets us define our data models in TypeScript and track every schema change through versioned migrations.

MongoDB: For Flexible Data

Our chat system stores messages in MongoDB, a document database. Chat data is inherently variable: text messages, media attachments, reactions, thread replies and MongoDB's flexible schema handles this naturally without forcing every message into the same rigid structure.

Redis: For Speed

Redis is our in-memory data store. We use it for caching frequently accessed data, managing user sessions, and powering job queues. Because Redis stores everything in memory, it responds in sub-millisecond times, critical for features where users expect instant feedback.

Event Streaming & Messaging

Apache Kafka

In a microservices architecture, services need a reliable way to communicate. We use Apache Kafka as our central event streaming platform. When something happens in one service: a user signs up, a token is created, a payment is processed, it publishes an event to Kafka. Other services that care about that event pick it up and react accordingly.

This event-driven approach means our services are decoupled, the payment service doesn't need to know about the notification service. It just publishes a "payment received" event, and any service that needs to act on it will.

We run Kafka in KRaft mode (removing the old ZooKeeper dependency) and have built our own internal NestJS library for decorator-based Kafka consumers and producers, making it as simple as adding an annotation to a method to start listening for events.

Blockchain & Web3

Smart Contract Development

We develop smart contracts using Foundry, a fast Solidity development toolkit written in Rust. Foundry gives us blazing-fast compilation, a powerful testing framework (tests are written in Solidity itself), and scriptable deployments.

Our contracts leverage OpenZeppelin for standard, audited implementations of common patterns (ERC-20 tokens, access control, upgradeable proxies), and we integrate with Uniswap V4 for decentralized trading functionality.

Blockchain Interaction

Our backend services interact with the Ethereum blockchain through Ethers.js, the most widely-used JavaScript library for blockchain communication. For data indexing and analytics, we use Moralis APIs alongside direct RPC connections via Chainstack.

Upgradeable Contracts

We use the UUPS (Universal Upgradeable Proxy Standard) pattern, which allows us to upgrade smart contract logic after deployment without losing any on-chain data. This is critical in a fast-moving product, we can fix bugs and ship improvements without requiring users to migrate.

Real-Time Communication

WebRTC & Mediasoup: Live Streaming

Our live streaming infrastructure is powered by Mediasoup, a WebRTC Selective Forwarding Unit (SFU). Instead of sending video from every participant to every other participant (which doesn't scale), the SFU receives one stream from each sender and intelligently forwards it to receivers. This supports high-quality H.264 and VP9 video with dynamic bitrate management.

Socket.io: Instant Messaging

Our chat system uses Socket.io for real-time, bidirectional communication between clients and servers. Combined with a Redis adapter, Socket.io scales horizontally across multiple server instances while keeping every connected user in sync.

Hasura: Real-Time GraphQL

For features that need real-time data synchronization, like live stream state, viewer counts, or content feeds, we use Hasura, which gives us instant GraphQL APIs over our PostgreSQL database with built-in subscriptions. Changes in the database are pushed to connected clients in real time.

DevOps & Infrastructure

Docker: Consistent Environments

Every service we build is packaged as a Docker container. Docker ensures that our code runs the same way on a developer's laptop, in staging, and in production. We use multi-stage builds to keep our production images small and secure.

Kubernetes: Orchestration at Scale

Our containers run on Kubernetes clusters hosted on AWS and DigitalOcean. Kubernetes handles scheduling, scaling, self-healing, and networking for all our services. We manage our Kubernetes configurations through Helm charts, templated packages that make it easy to deploy complex applications with a single command.

ArgoCD: GitOps Deployments

We follow a GitOps workflow, where our entire infrastructure and application configuration lives in Git. ArgoCD continuously watches our Git repositories and automatically synchronizes our Kubernetes clusters to match the desired state. This means deployments are as simple as merging a pull request, and every change is traceable and reversible.

GitHub Actions: CI/CD Pipelines

We run 88+ automated workflows through GitHub Actions. Every pull request triggers builds, tests, and security scans. When code is merged, our pipelines build Docker images, scan them for vulnerabilities with Trivy, push them to our container registry, and trigger ArgoCD to deploy.

Ansible: Server Configuration

For tasks that go beyond containerized applications, like setting up security monitoring agents or hardening server configurations, we use Ansible playbooks. Ansible lets us define server configurations as code and apply them consistently across our infrastructure.

Security

Security is not an afterthought, it is built into every layer of our stack.

Secrets: HashiCorp Vault stores and manages all sensitive credentials with encryption and access control

Container Images: Trivy scans every Docker image for known vulnerabilities before deployment

Network: Snort3 provides intrusion detection and prevention at the network level

Application: Sentry tracks application errors in real time, enabling rapid incident response

Infrastructure: Wazuh provides centralized security monitoring, log analysis, and compliance auditing

SSL/TLS: Cert-Manager automates certificate provisioning and renewal across all services

Monitoring & Observability

Knowing what's happening inside our systems is as important as building them.

Prometheus collects metrics from every service: request rates, error rates, response times, resource usage. Grafana turns those metrics into visual dashboards, giving our team a real-time view of system health. Sentry captures and groups application errors with full stack traces, so we can identify and fix issues before they impact users. Wazuh monitors security events across our entire infrastructure, alerting us to suspicious activity.

Third-Party Services

We integrate with best-in-class third-party services where it makes sense to buy rather than build:

Payments : Stripe processes payments, subscriptions, and payouts

SMS: Twilio Sends verification codes and transactional SMS

Email: Mailgun Delivers transactional emails at scale

Push Notifications: Firebase Cloud Messaging Sends push notifications to iOS and Android devices

CMS: Strapi Powers our blog with a headless content management system

Blockchain RPC: Chainstack Provides reliable Ethereum node access

Blockchain APIs: Moralis Supplies indexed blockchain data and webhooks

Cloud Storage: AWS S3 / DigitalOcean Spaces Stores user-uploaded media and backups

Our Philosophy

A few principles guide every technology decision we make.

Choose boring technology where it counts. PostgreSQL, Kafka, Docker, Kubernetes: these are proven, battle-tested tools with massive communities. We save the cutting-edge decisions for where they truly matter: blockchain, real-time streaming.

Automate everything. From deployments to backups to security scanning, if a human has to do it manually, it will eventually be forgotten or done wrong. Our pipelines handle it.

Build for testability. Every service is designed to be testable in isolation. We use dependency injection, mock external calls, and run integration tests against real databases using Testcontainers.

Own the critical path, outsource the rest. We build our core platform in-house but rely on Stripe for payments, Twilio for SMS, and Mailgun for email. No need to reinvent what others do best.

Security is a feature, not a checklist. Vault for secrets, Trivy for images, Wazuh for monitoring, Snort for network, security is woven into every layer, not bolted on at the end.

This post reflects our technology stack as of early 2026. As our products evolve, so will our tools; but the principles behind our choices remain the same.

If you are evaluating a technical partner and want to understand what production-grade engineering looks like in practice, get in touch with the Red Rock team.