Unify Transactional and Analytical Data with VAST DataBase

Asking an AI to build order billing gets you a bloated OrderService class holding thousands of lines of queries. This happens because code assistants default to copying the database wrappers they saw in public repositories. Accepting these default files leaves you with database tables disguised as code logic. Get tighter code by reversing the order. Define the domain types and allowed state transitions yourself. Feed those types to the prompt. Tell the model to write logic matching those rules, and forbid it from creating service classes. AI generates excellent code when you supply the constraints first.

Ai4 in Vegas last week, and this morning's headlines — CoreWeave revenue doubling, Oracle borrowing to build more data centers — are telling the same story from both ends. The industry is pouring capital into bigger models and more compute, while a lot of the enterprise AI pilots I talked to on the floor still can't graduate out of the pilot stage. The gap isn't horsepower. It's scope. The teams actually shipping didn't hand a model their whole workflow and cross their fingers. They took one bounded job — reconcile these statements, draft this first pass, flag these exceptions — gave it clean inputs, and put a check on the output before anything downstream trusted it. Unglamorous on a keynote slide. But that's the version that runs on a Tuesday without a human hovering over it. More compute makes a better demo. Tight scope plus a verifiable output makes a system you can actually control. The companies that internalize that over the next year are going to quietly outrun the ones still waiting for the model that finally does everything. What's the narrowest job you'd trust AI with today?

We used to send everything through one big LLM. Every call. Every tag. Every decision. Cost got too high, too fast. So we stopped and looked at what we were doing. Most of the work was easy. Did the customer say yes or no. What was the call about. Small stuff like that. We were using a top model for this. Big waste. We moved it to a smaller model. Open source. We run it ourselves. Same accuracy. Much cheaper. Next problem. Some calls have private info. Loan details. Personal data. We didn't want that going out to some outside API. So we run that on our own servers too. Local. In-house. It's faster too. No round trip over the internet. But some things still need a strong model. A customer getting upset. A tough negotiation. Tone matters here. Timing matters. We use enterprise LLMs for this. No shortcuts. So now we use 3 levels. Easy task, small model. Private data, local model. Hard task, big model. Our costs went down a lot. Nothing got worse. Wish we knew this on day one. Not month 6. Predixion AI

LLM Rate limits needs Capacity Planning: A lesson learned the hard way !!! My Agentic Data Pipeline had three AI workloads sharing the same LLM API quota: 1. Live inference, which ran roughly every 4 hours and had the highest priority 2. Offline Evals, which were occasional and delay-tolerant, only needed during Regression / CICD / Prompt Migrations 3. Historical Backfills, which were long-running, high-volume workloads, only needed during Prompt migrations I started thinking about the total RPM quota as a budget: Total RPM = X + Y + Z + W, where X = Live Traffic, Y = Backfill Capacity, Z = Eval Capacity, W = Headroom for spikes and retries. Simply adding exponential backoff wasn't enough. A backfill could behave perfectly according to its retry policy and still consume capacity that live inference needed. The interesting part was that X, Y, Z, W weren't static. During a migration, I might need to take capacity assigned to an existing backfill and give it to a new migration. But I couldn't simply change Y and immediately start the new worker because the old backfill could still have requests in flight. The handoff became: stop new work -> drain in-flight requests -> reallocate quota -> start new backfill. Live traffic kept its reserved capacity throughout, eval capacity could temporarily shrink, and headroom remained available for spikes and retries. I exposed these allocations through internal developer controls so this could happen without redeploying the application. The biggest distinction I learned was that handling rate limits and accounting for rate limits are different engineering problems. Retries, backoff, and jitter are reactive mechanisms for requests that hit capacity. Rate-limit accounting is about deciding who should get that capacity in the first place. Once live inference, evals, and backfills share the same model provider, API quota starts looking a lot like CPU, memory, or database connections, basically a finite resource that needs prioritization, reservation, headroom, and safe reallocation. PS: The screenshot you see below is from my Dev dashboard where I can observe the RPM consumption by my AI Agent in real-time. Link: https://lnkd.in/gHqUrKsx Source: https://lnkd.in/giTBR5yC #AI #LLM #AgenticAI

AI is writing code faster. We're focused on what that means for the database, making sure code stays reliable and scalable.

The conversation around AI often focuses on h𝐨𝐰 𝐦𝐮𝐜𝐡 𝐟𝐚𝐬𝐭𝐞𝐫 𝐰𝐞 𝐜𝐚𝐧 𝐝𝐞𝐥𝐢𝐯𝐞𝐫. The more important question is: 𝐂𝐚𝐧 𝐨𝐮𝐫 𝐠𝐨𝐯𝐞𝐫𝐧𝐚𝐧𝐜𝐞, 𝐪𝐮𝐚𝐥𝐢𝐭𝐲, 𝐚𝐧𝐝 𝐞𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐩𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬 𝐤𝐞𝐞𝐩 𝐩𝐚𝐜𝐞? AI is dramatically increasing the speed at which applications—and increasingly databases—are changing. That's an incredible opportunity, but it also exposes a challenge many organisations are beginning to experience. Processes designed for a slower delivery cadence simply weren't built for today's velocity. This is where modern Database DevOps becomes critical. The goal isn't to slow innovation down. It's to ensure every database change is: • Version controlled • Governed by policy • Automatically validated • Delivered with confidence As AI continues to accelerate software delivery, organisations that automate governance—not just development—will be the ones that scale successfully. Engineering excellence has never been about moving fast alone. It's about moving fast w𝐢𝐭𝐡𝐨𝐮𝐭 𝐜𝐨𝐦𝐩𝐫𝐨𝐦𝐢𝐬𝐢𝐧𝐠 𝐬𝐭𝐚𝐛𝐢𝐥𝐢𝐭𝐲, 𝐬𝐞𝐜𝐮𝐫𝐢𝐭𝐲, 𝐨𝐫 𝐭𝐫𝐮𝐬𝐭. Redgate's latest insights on Flyway Enterprise provide a great perspective on this challenge and how teams can modernise database change management. #DatabaseDevOps #DevOps #PlatformEngineering #AI #AgenticAI #SoftwareEngineering #EngineeringExcellence #Flyway #Redgate #DigitalTransformation #BlueTurtleTechnologies

AI is speeding everything up, including database changes. It’s fast, and often good. But the processes that worked fine last year are now creaking under that pressure. Manual review cycles simply can’t keep up when this many changes move this fast. That’s where Flyway Enterprise comes in; it scales the code review practices teams already trust with custom policy integration, version-controlled schema changes, and automated policies in the pipeline. The standards you rely on today still hold as delivery accelerates. Faster database changes. Same stability, predictability, and trust. That's what governing at scale looks like. https://rd.gt/4pCjgnv

Text-to-SQL benchmarks don't translate to real-world performance. The best models score 91% on academic text-to-SQL benchmarks but only solve 21% of real enterprise workloads. Real schemas are incredibly messy, and have lots of traps that make it trivial for AI agents to deliver plausible-but-incorrect answers. The problem is missing context: semantic layers that constrain what an agent can claim, lineage for answers instead of just pipelines, identity for agents acting on someone's behalf. Trust is one of the four themes at Data Outpost, our two-day conference in San Francisco this November. The question: how do you trust AI-assisted analytics? dataoutpost.ai

Most data teams know their platform bill is climbing. Almost none can answer the follow-up questions: why, and who owns it? Query costs, cluster spend, and now AI query costs have historically lived in separate systems, making cost accountability nearly impossible to enforce. Starburst Console, the new admin experience in Starburst powered by AIDA, changes that. This session introduces a unified FinOps approach that covers all three cost dimensions in one view: traditional query workloads, cluster-level spend, and the emerging cost of AI-powered queries through AIDA. You’ll see how the new experience attributes costs by team, workload, and query type, including which AIDA interactions are driving the most consumption and how to use that visibility to optimize, charge back, and govern AI spend before it becomes a budget conversation you weren’t prepared for. You'll leave with: ✔️ A FinOps framework for query engines that now includes AI: how to think about cost attribution across traditional and AI-powered workloads ✔️ A live walkthrough of the new unified cost + usage view in Starburst, including how AIDA query costs appear alongside standard compute spend ✔️ A chargeback model you can bring back to your organization, covering both data and AI consumption in one report Register: https://okt.to/ViEQxy #FinOps #DataEngineering #CloudCosts #EnterpriseData

I had real fun building an internal business dive‑deep engine using Opus 4.8 (with a bit of Fable 5) on AWS.   A few things I learned taking AI from demo to enterprise grade:   1. Latency and accuracy aren't a trade‑off: Both have to clear an acceptable bar - a fast wrong answer and a slow right one both lead to user churn.   2. System prompts can't be SOPs: For a general‑purpose engine, they have to encode principles of thinking - how to look at a business - and let the model reason from them, not follow a script. 3. The data layer is half the product: Craftful data engineering that optimizes compute time, plus customer‑obsessed judgment about which features actually matter, is what makes it usable at scale.    #AI #IndiaGlobalSelling