Vinoo Ganesh

20% confidence prediction I've had for a while: labs will stop offering API access to frontier models altogether to force people to use their proprietary products. Builders that aren't competing will be fine (OSS, previous-gen models, etc), but it'd very tough to compete directly in the niches they care about.

49

6 Comments

When building a full data stack implementation for our clients at South Shore Analytics, several factors weigh into which data movement platform (e.g. Airbyte, Portable, Fivetran, etc.) we'll use for the project (if any): * Which platform can support the greatest number of our clients' data sources OR, more importantly, eliminate the most future headaches. In some cases it's better to go with the platform that can handle fewer of our sources if they can take care of the pipeline that is going to be the most difficult to self-develop. * Pricing for our clients (some platforms are getting away with charging obnoxious prices for tasks that can be developed in-house with a low level of effort) * How familiar we are with the platform (not a dealbreaker, but lower the learning curve the better) And sometimes it makes the most sense for us and our clients to just self-develop a few pipelines and run them through a tool like Orchestra if the requirements are simple (or complex :) enough).

20

4 Comments

The $340K mistake we almost made on our latest database migration. Last month, our client's DBA suggested a "quick weekend migration" from DB2 to PostgreSQL for their financial system. My gut said no. Here's why that decision saved the project: The hidden complexity: What looked like a straightforward database swap turned into discovering 1,200+ custom SQL queries buried in 15 years of code. Each one a potential point of failure. The real insight: Legacy modernization isn't a technology problem—it's a risk management problem. Instead of the weekend approach, we spent 3 weeks just cataloging every query. Boring? Absolutely. Critical? That catalog became our migration roadmap and saved us from what could have been weeks of production fires. What actually moved the needle: → Building a translation layer that let us test in parallel → Moving 10% of traffic at a time instead of all-or-nothing → Having a rollback plan for every single step The migration worked. But the lesson was bigger: when modernizing legacy systems, the methodical approach always beats the heroic approach. One question for fellow architects: What's the most unsexy preparation work that saved your project? Sometimes the best engineering stories are about the disasters we prevented, not the features we shipped. For the full technical deep-dive on how we built the translation layer and our complete migration strategy, I've written up the complete case study: https://lnkd.in/g9r--DnW #LegacyModernization #DatabaseMigration #SoftwareArchitecture #TechLeadership

12

1 Comment

Just-in-Time UI: At Aligned Labs we frequently share reports about the data collection, fine-tuning and eval work that we do with clients.  They often need different views or refined analysis, which is why we built Whiz-bang Boom! Our new tool takes a CSV or JSON file and generates a shareable, interactive report. You can easily modify the report or focus the analysis with a simple prompt, and it creates a new revision. You can organize reports into spaces and customize those spaces with a simple prompt. Try it out. https://wizbangboom.com #businessIntelligence #AI

25

2 Comments

A competitor just told our lead they charge 10x for drift detection. 10x. For a cron job that runs terraform plan. That's not a pricing model. That's contempt for your operational safety. Drift detection is 50 lines of code. Schedule. Compare. Alert. Your intern built this last week. But the moment you need it reliable, documented, at scale, suddenly it's "enterprise functionality." They're charging you $50 for airport WiFi because they know you're trapped. They KNOW drift kills. They KNOW you need this. And instead of making it table stakes, like anyone who actually cared about your infrastructure would, they're betting you're too scared of compliance to push back. We've normalized vendors treating our basic safety as a luxury good. Stop accepting this.

47

8 Comments

Coming soon to bitdrift real-time dynamic observability: session span views! Let me tell you why I am so excited for this feature. Traditional tracing requires some type of sampling to control volume and cost. "Head sampling" is the simplest and just decides at the beginning of the trace whether to capture it or not. Thus sampling does not have any trace specific context. "Tail sampling" is more sophisticated and decides at the end of the trace whether to capture (based on observing an error or some other indicator). Without real-time control and local storage, this requires sending *all* data to some intermediate buffer where it can be held to make a decision. As a result, "tail sampling" is still expensive, and the total trace duration is usually short. None of these downsides apply with bitdrift Capture's real-time control and local storage. Sessions can be hours or days long, and the capture decision is based on dynamic state machine execution. With this solution you will be able to capture sessions and performance tracing based on arbitrary matching criteria, and update that criteria in real-time, getting you the traces you need to iteratively debug performance issues all without a single code deploy. Can't wait to ship this! 🚀

45

The future of GTM isn’t headcount. It’s infrastructure. You don’t need more SDRs. You need better systems. The companies that are scaling right now aren’t hiring faster. They’re building smarter. → Enriched data flows → Instant routing logic → Agent-led follow-up → Continuous learning loops This is the shift from manual ops to GTM engineering. From reacting to events, to designing for them. It’s not just automation, it’s autonomy. The sooner you invest in this foundation, the sooner your reps stop chasing forms and start chasing revenue.

17

1 Comment

And for the final launch of this week! Plano offers a unified v1/responses API for any LLM provider via Supabase! Works for models hosted on Amazon Bedrock (cc Swami Sivasubramanian) Model agility is a critical part of "delivering" agentic applications and we just made that super simple for any AI developer. The OpenAI Responses API (v1/responses) is designed for multi-turn conversations where context needs to persist across requests. This pattern dramatically reduces bandwidth and makes it easier to build multi-turn agents — Plano handles the state plumbing and converting API shapes seamlessly between providers so you can focus on agent logic. Unlike the traditional Chat Completions API where you manually manage conversation history by including all previous messages in each request, Plano handles state management behind the scenes. This means you can use the Responses API with any LLM provider, and Plano will persist conversation context across requests—making it ideal for building conversational agents that remember context without bloating every request with full history. 🏗️ How It Works When a client calls the Responses API: 1️⃣ First request: Plano generates a unique resp_id and stores the conversation state (messages, model, provider, timestamp). 2️⃣ Subsequent requests: The client includes the previous_resp_id from the previous response. Plano retrieves the stored conversation state, merges it with the new input, and sends the combined context to the LLM. 3️⃣ Response: The LLM sees the full conversation history without the client needing to resend all previous messages. Check out the links in the comments section for more details to try it out!

18

1 Comment

The Stacklok team has been spending a lot of time looking at ways to improve the security of code generation workflows. Using a modern frontier model helps, but that isn't for everyone or every task. For folks using mid-sized models for simple generation workflows, check out our findings comparing popular models here: https://lnkd.in/gC4PknJY tl;dr; * All models struggle with bad package detection (Llama 3.2-3B was better with 29% packages flagged, but most only came in detecting around 5%). * CVE knowledge is low (with peak awareness of 18% for Qwen2.5-Coder-3B-Instruct, but 5% being more typical) * Insecure code recognition is a mixed bag. * Size isn't everything (some smaller models out-performed larger models) * Newer isn't always better. Check out the linked post for details, and check out Codegate if you are using smaller models for agentic workflows and want extra security.

39

A.I. Clouds are not all the same. Justin Gage of Amplify Partners shares, in explicit detail, how Modal is just built different, and why it's a mistake to think of them as an "inference provider". https://lnkd.in/gmaYQZtT

55

Really proud of the work Harry Pierson and the team have done in releasing DBOS Java today! DBOS Java brings lightweight durable workflows to Java. Workflows make your program durable by checkpointing its state in Postgres. If your program ever fails, when it restarts all your workflows will automatically resume from the last completed step. Workflows are useful for solving many problems, such as: - Orchestrating business processes so they seamlessly recover from any failure - Operating an AI agent, or anything that connects to an unreliable or non-deterministic API. - Running reliable background jobs with no timeouts. - Processing incoming events (e.g. from Kafka) exactly once What’s unique about DBOS workflows is that they’re implemented entirely in a lightweight Postgres-backed library. All you have to do to use DBOS is install the library into your application and register workflows and steps. As your program runs, the library checkpoints your workflows and steps in Postgres. If your program ever fails, when it restarts it uses those checkpoints to resume all your workflows from the last completed step. There are no other dependencies you have to manage, no separate workflow orchestrator–just your program and Postgres. The big advantage of this approach is that you can incrementally add DBOS to any Java application–it’s just a library. You can add workflows to your application without rearchitecting it or adopting any new infrastructure. It works out of the box with frameworks like Spring. Also, because it’s all Postgres-backed, you get all the tooling you’re familiar with: backups, GUIs, CLI tools–it all just works. You can use Supabase, RDS, Neon, or any other Postgres provider. Check it out on GitHub, try it out, and give us a star!

48

6 Comments

How can you make sure orchestrating agents across many frameworks doesn't cost you a fortune? Today, Caelum Forder and I look into agent sessions from Coral Protocol.

16

Databricks Lakebase just dropped! It finally bridges operational and analytical databases - something data pros have wanted for years. By bringing separation of compute and storage to Postgres-like operational systems, it enables AI agents to spin up sandboxed, versioned databases in seconds. Imagine your coding agent testing new features on a full product DB clone - safely, instantly. Total game changer.

25

1 Comment