Tino Tereshko 🇺🇦

🔍 The observability infrastructure landscape is getting complex. I've been thinking about how teams actually choose between the growing number of options—GreptimeDB, VictoriaMetrics, ClickHouse, Apache Pinot, traditional stacks, and more. So I mapped out the key technical decision points: 🔓 Open source vs. proprietary 🔍 SQL + PromQL requirements 🔄 OpenTelemetry compatibility 🗃️ Unified data model needs (logs, metrics, traces) ☁️ Cloud-native architecture (compute-storage separation) 🪣 Object storage integration 📋 Materialized views ❤️ A few observations from the analysis: The architecture question is critical. Most solutions still use traditional coupled storage-compute models. Only a few (like GreptimeDB and Apache Pinot) implement true compute-storage separation, which matters significantly at scale. VictoriaMetrics is excellent for metrics-focused use cases, but locks you into that domain. ClickHouse requires substantial custom work for observability patterns. Multi-component stacks (Jaeger + Prometheus + ELK) work but the operational overhead adds up quickly. 👍 The interesting part: When you map out all the requirements, very few solutions check every technical box. Most force architectural compromises. Built this decision tree to help teams think through the trade-offs systematically rather than getting caught up in feature comparisons. 🎯 DECISION FRAMEWORK: 1️⃣ Need ALL requirements met? → GreptimeDB (only complete solution) 2️⃣ Metrics-focused only? → VictoriaMetrics (not cloud-native but excellent performance) → GreptimeDB (if you need cloud-native) 3️⃣ Have ClickHouse expertise? → ClickHouse + custom PromQL layer → GreptimeDB (simpler path) 4️⃣ Enterprise/existing tools? → Traditional stack (complex but battle-tested) → GreptimeDB (unified alternative) Curious about others' experiences - what's been the biggest technical challenge in your observability infrastructure decisions? 🤔 #Observability #Infrastructure #Database #TimeSeries #GreptimeDB #Monitoring

12

Data modeling and ontologies called out as foundational values 👀 in a post from Henrique Dubugras, one of the founders of Brex describing his ideal CTO for his new co. CC Joe Reis Jessica Talisman #ontologies #datamodeling

68

10 Comments

Break down how TiDB handles 1M rows/sec in production — the complexity of multi-tenant SaaS architectures actually feasible by #TiDB

1

A recent blog post titled “650GB of Data (Delta Lake on S3). Polars vs DuckDB vs Daft vs Spark” has been getting a lot of attention (including the front page of Hacker News). Its main claim is that single-node engines can easily handle “large” datasets—650GB in this case—for practical analytics. 🔗 https://lnkd.in/eTx8s9GD This post is quite misleading about the actual amount of data processed. The dataset may be 650GB in total, but the query touches only one out of 35 columns. In a columnar format, this means just a small slice of the dataset—likely only a few gigabytes—is actually scanned. Because of this, the working set fits comfortably in memory and doesn’t require streaming or out-of-core execution. The computation itself is also straightforward: read a batch of data, convert to date values, and compare against a small (≈365-entry) lookup table. In reality, the dominant cost here is S3 I/O, not compute or memory pressure. This kind of nuance often gets lost online, where simplified narratives about “handling hundreds of gigabytes on a single node” tend to overshadow the technical details that actually matter. Personal note: As engineers, we show up every day to solve real problems and build technology that genuinely helps people. It’s a bit deflating when oversimplified or sensational posts drown out thoughtful, technically grounded discussions. I wish accuracy mattered more online than whoever can grab the most attention.

141

33 Comments

Big Data's biggest bottleneck is Big Context. Jason describes the data context problem that's been a blocker for a new wave of AI apps like data analyst agents, "chat with your data" bots, and text-to-SQL tools. But until the context problem is solved, every "agentic" data product is just a party trick. At Puller AI, we've been hard at work closing the context gap for our growing network of data-driven customers. Our goal is simple: make data context a first-class, continuously maintained runtime so AI apps can finally graduate from interns to experts.

40

7 Comments

Debugging Airflow + dbt + Snowflake usually means jumping between logs, DAGs, and SQL. With Cortex Code CLI, you can handle it from your terminal with one prompt. In the demo, we asked why a dbt model wasn’t populating. Cortex Code checked the DAG, read logs, inspected SQL, queried upstream tables, and found the broken source. Minutes instead of hours. What will you build with Cortex Code? Get started: https://lnkd.in/dU6rDtrC

71

1 Comment

Karpathy released a new repo .. and it proves our current CI/CD infrastructure is a bottleneck for Swarms. 🛑 As AI Architects, we are scaling from single-agent workflows to massively parallel Multi-Agent Systems (MAS). But we are still forcing these autonomous entities to collaborate using human-centric platforms like GitHub. When an agent can iterate a codebase 100 times an hour, relying on linear branches and manual Pull Requests completely breaks the execution loop. I've been analyzing Andrej Karpathy's new project, AgentHub (karpathy/agenthub), and it introduces a radically different architectural approach: Agent-Native Collaborative Version Control. The Architectural Primitive: Instead of mimicking human Git workflows, AgentHub is a lightweight, Go-based synchronization layer designed strictly for programmatic collaboration. DAG-Based Commits: It completely drops the concept of a "Main Branch" or "PRs". Agents push git bundles directly into a continuous Directed Acyclic Graph (DAG) of experiments, allowing massive parallelization of code synthesis. Stateful Message Boards: It decouples code from reasoning. Agents share hypotheses, execution failures, and hyperparameter adjustments in threaded channels, essentially creating an automated "research culture." Decentralized Swarm Execution: Built to support his autoresearch framework, it allows disparate AI agents across the internet to securely connect, pull the latest experimental state, run localized training loops, and push the results back to the community. Zero-Bloat Stack: It runs as a single compiled binary backed by SQLite and a bare git repository, making it trivially easy to deploy as an orchestration backend. Why it matters: If you are building Agentic Workflows, you must stop treating AI as a "developer" that submits PRs. We need native execution hubs where agents can asynchronously share state, code, and telemetry without human bottlenecks. Do you think decentralized agent-hubs will eventually replace standard Git providers for AI-generated codebases? 👇 Link to the repository in the comments. #AIArchitecture #SystemDesign #AgentHub #MachineLearning #MultiAgentSystems #Karpathy #AgenticAI #LLMOps

10

2 Comments

RAG was phase one.The next competitive layer may be observational memory. New evidence suggests memory-augmented agents can reduce costs by up to 10x and outperform classic RAG on long-horizon tasks. This is not a marginal improvement. It’s an architectural shift. Enterprise AI will not be defined by larger models, but by how we design memory, continuity, and evaluation at system level. Once agents retain structured memory, evaluation shifts from accuracy per prompt to stability and alignment over time. The question is no longer “Which model?” It is “What cognitive architecture are we building?” #AgenticAI #AISystems #AIArchitecture #EnterpriseAI #Innovation https://lnkd.in/ebSGNp5g

57

5 Comments