Blog

Learn how to keep OLTP fast while streaming changes to ClickHouse for lightning-quick analytics. This code-first guide uses Debezium, Redpanda, and MooseStack to model CDC, transforms, and OLAP tables you can spin up locally in seconds. (more)

OLAP databases don’t update — they merge. When streaming CDC data into ClickHouse, every change is an insert. The table engine you choose defines how those inserts turn into a correct, queryable view of your data. (more)

Learn how insert patterns differ between OLTP and OLAP databases — and how ClickHouse and MooseStack can help you optimize for each. From batching strategies to streaming buffers, discover practical heuristics to balance performance, freshness, and resilience. (more)

ClickHouse’s new JSON column type bridges the gap between flexibility and OLAP efficiency. This post explores how explicit and implicit subcolumns let you query nested data without sacrificing performance — and why understanding how ClickHouse handles NULLs is key to modeling real-world JSON. (more)

When working with OLTP databases, NULL values are a flexible way to represent unknown data. But in the world of OLAP — where performance depends on columnar efficiency and compression — NULL can become an expensive mistake. In this post, we unpack why NULLs slow down analytical workloads, how ClickHouse handles them internally, and what patterns (like sensible defaults or sentinel values) you can use instead. (more)

Nested and irregular data structures are powerful for ingestion—but brutal for analytics. This article explores why JSON-heavy and shape-shifting data patterns complicate OLAP performance, and how to tame them with schema-on-write strategies, materialized views, and ClickHouse tricks. Whether you’re modeling logs, telemetry, or e-commerce data, you’ll learn how to keep the elegance of nested data without losing analytical speed. (more)

This article explains how OLAP databases like ClickHouse and DuckDB differ fundamentally from OLTP systems in their design and purpose. It dives into how columnar storage and analytical workloads reshape schema design, comparing traditional star schemas with modern wide, denormalized tables. You’ll learn why storage duplication is no longer the enemy, why joins slow down analytics, and how schema design in OLAP effectively is the query plan. (more)

This post explores why ORDER BY is a critical performance factor in OLAP databases like ClickHouse. Using clear analogies (like grocery store layouts vs. maps) and real-world benchmarks (aircraft telemetry data from ADSB.LOL), it shows how ORDER BY improves efficiency compared to OLTP indices. You’ll also learn practical heuristics for choosing the right fields — from low-cardinality booleans to time-based clustering — and how they impact ingestion, compression, and query speed. (more)

Cardinality plays a critical role in OLAP database performance, especially when balancing compression, encoding, and query efficiency. This guide breaks down cardinality types with practical examples, including LowCardinality wrappers, enums, and heuristics for choosing the right column types. Perfect for engineers optimizing high-volume analytics workloads. (more)

The article talks about why typing matters in OLAP systems like ClickHouse, covering efficient type choices, when to use LowCardinality, and the tradeoffs of strict schema design, with a guide for AI copilots and links to best practices. (more)

At Fiveonefour, we built Area Code—a reference application that demonstrates how to add an analytical layer to a transactional system using our OSS framework, MooseStack. This blog introduces why we created Area Code, the challenges it addresses, and the insights we’ve gained from building it. It’s the first in a series of articles sharing our learnings with the community. (more)

We asked the community if OLAP needs ORM-like DX. The consensus: keep SQL first-class, add type-safety and contracts, and build toward a semantic layer. Here are the sharpest arguments—and what we’re building next. (more)

Traditional ORMs break when applied to OLAP databases. We worked with ClickHouse to explore why columnar stores require a new, OLAP-native approach to developer abstractions (more)

The Connector Factory reimagines data integrations by combining clear specifications, standardized scaffolding, and AI-powered agents to deliver production-ready connectors in hours instead of weeks. By turning every new connector into a learning loop, the system continuously improves—making integrations faster, more reliable, and fully open source for developers to use or extend. (more)

Joj benchmarked PostgreSQL vs ClickHouse on 10M rows to see how an AI agent might explore data. The test revealed when ClickHouse pulls ahead, how one schema change delivered a 50× speedup, and why LLMs make these optimizations easier than ever. (more)

Lifecycle Management gives you fine‑grained control over how Moose applies schema changes as your code evolves—keep automation in dev, add deletion‑safe guardrails in prod, or integrate with CDC/external databases for full control. Choose per resource—Fully Managed, Deletion Protected, or Externally Managed—across tables, streams, and ingestion pipelines. Available now in v0.4.320+; docs: moose.514.dev/moose/building/lifecycle. (more)

Lessons we learned from Moose CLI to keep terminals clean after Ctrl+C—no more garbled prompts or lingering processes. (more)

ClickHouse is a blazingly fast open source analytical database. We love Clickhouse here at Fiveonefour, and we’re on a mission to make Clickhouse accessible to every developer. If you’re a developer building on ClickHouse, you’ve come to the right place ;) Read on to learn about Fiveonefour's dev tool stack to enable Clickhouse developers... (more)

If you've worked with SQL databases like ClickHouse, you know that changing one object—say, a table—can have ripple effects on dependent objects like Materialized Views (MVs) or other views. Applying these Data Definition Language (DDL) changes in the wrong order often leads to errors and headaches. This post explains how Moose handles these SQL dependencies to make your infrastructure updates reliable during development with moose dev. (more)

Build a real-time GitHub analytics dashboard in a few hundred lines with Moose. Learn to ingest and enrich GitHub data, expose a type-safe API, and deploy a production-ready stack—all with minimal code and maximum speed. Perfect for tracking open-source trends or launching your own analytics project. (more)

Medallion architectures aim to deliver high-quality data products through distinct quality levels but face scalability issues as demand for these products increases. AI agents can address this by automating data quality improvement, speeding up the process from bronze to gold levels while maintaining high standards. Combined with federated data architectures and scalable frameworks, AI agents can significantly enhance data engineering capacity and deliver high-quality data at scale. (more)

The blog explores how Model Context Protocols (MCPs) are emerging as the next evolution beyond traditional APIs, enabling LLMs to interact with systems in flexible, agent-native ways. Just as APIs turned complex backend tasks into simple programmatic calls for apps, MCPs abstract complexity for LLMs, but require handling non-determinism and reasoning, not just static tasks. This shift could create a new wave of "API winners" in domains previously considered too human-centric to automate. (more)

The blog post discusses how the author created a template to ingest Goodreads data from Kaggle to demonstrate the capabilities of their advanced AI tools, including data ingestion and analysis. It provides a detailed guide on how to set up the tools, ingest the dataset, explore the data with AI, and even productionize results . (more)

This blog walks through setting up a Moose project to track military aircraft data using a Moose / Aurora ADS-B template, with a focus on leveraging Aurora MCP tools for data exploration and productionizing APIs. It provides a step-by-step guide to exploring and analyzing transponder data, using Claude Desktop and Cursor for insightful queries and visualizations. (more)

The blog post discusses the challenges of using MCPs in different clients, particularly Claude Desktop and Cursor, with frustrations around config JSON setup, updates, and PATH inheritance. (more)

Discover how F45 Training, the global boutique fitness franchise, rolled out user-facing analytics 10x faster and 50% cheaper with Fiveonefour, unlocking an immersive mobile app experience for their Lionheart biometrics and connected-fitness users. (more)

Download and try out Aurora's first workflow: getting data from an API into your clickhouse database! (more)

A hands-on approach to domain-driven data products, automated data pipelines, and scalable governance. (more)

(more)

(more)

(more)

(more)