Before we begin, here’s a bit of context. I started FireBird Technologies in November 2023 with the goal of building the leading AI SaaS product and services company. Before that, I worked as an independent tech consultant for Vanna.ai, one of the most powerful data agent frameworks.

Over the past three years, my team and I have worked on more than 20 AI SaaS products. Some were our own products and others were built as the technology partner for SaaS companies. Here are some of the projects we’ve worked on.

Watch the video version of this post:

Internal Projects

1. AutoAnalyst.ai — An AI data scientist platform. The hosted version has served over 1.8K users and 5K requests analysis performed. It has also been deployed inside other companies’ infrastructure, bringing in hundreds of thousands in service revenue. The project is open source under the MIT license with around 670 stars.

2. Blog2Video — A text-to-video content automation SaaS. Launched in February 2026 and already at about $1.3K in revenue with fast growth. .

3. AutoDash — A simplified AI visualization tool. Focused more on designing visualizations than autoanalyst.

4. AutoForm — An AI MicroSaaS form builder we use internally to capture leads.

5. SQLTrainerAI — An AI simulator designed to help people learn SQL.

Client Projects:

Most client identifiers have been removed due to NDAs and but I do have consent to talk about the projects without referring to them. Below are just examples of the work we have done for $Bn companies, VC-funded startups and academics.

1. KPAI — A research project for Michael Schrage on how different AI agents can become KPI indicators and specialists.

2. CyberSecurity & Threat Analyst — An AI RAG system which detects malicious content on the dark web.

3. AI Digital Marketing Analyst — A variant of the autoanalyst that was purposefully engineered for a digital marketing company. Giving them insights into campaign performance, ROI and marketing spend.

4. AI Property Management — A property management system that looked into Co2 emissions, property layouts and development contracts to provide insights to property developers.

5. AI Knowledge Base for a Consulting Firm — A knowledge graph–based AI agent that connects multiple knowledge centers to provide unified insights for a management consulting firm.

It’s safe to assume my experience speaks for itself. In the next section, I’ll share the mistakes I made, what I saw clients do wrong, and the approaches that actually worked.

Hire me & my team for your next project. We have built over 20+ app, many in production for startups, $Bn companies & academics.

Reach out here: https://tally.so/r/3x9bgo

What did not work

Starting off with things that did not work. Many of these things looked good on paper but did not materialize any meaningful impact on the product’s revenue or improve user experience.

Trying to optimize what AI framework to use

Between 2023 and 2025, AI Twitter was full of debates over which AI framework to use. From experience, I can say that calling the API directly or building your own orchestration layer usually works better than relying on a framework. Some frameworks, like DSPy, can be useful for evaluation, but beyond that, it doesn’t make a real difference.

A lot of time and energy was wasted learning these abstractions, but it doesn’t improve the product — the user doesn’t care!.

Making your app LLM agnostic

This is one that I personally fell for. On the surface it isn’t a bad idea, you give the user more options on which provider they can choose. In theory that should help you, but most users don’t care that much. A subset of users which are tech savvy, privacy focused & politically active might care but for most users it isn’t a big concern.

It only makes your app harder to maintain and also it makes the user experience unpredictable. One user might be going through their favorite provider, only for the API to be down. Every time the model API upgrades you need to change your system, more APIs integrated more upgrades.

It creates more problems than it solves, unless it is the core proposition of your product. Keep only two (one core model the other backup/support cheap model) models. Makes for smoother development and less headache.

Focusing on technology hype

The tech sector has had this problem for a long time. A new hyped-up technology enters the scene and everyone on LinkedIn/X starts promoting it like it’s the next big thing. In the AI era, these include Graph-RAG, MCP, Agentic Memory, Open Claw, and similar tools. These technologies have use cases, but for the most part, they are overhyped. You should focus on them only if they help solve your core problem: getting more paid users.

The MCP vs CLI debate is ongoing, with people divided into both camps. I think it’s mostly a distraction. MCP is useful if your product is for technical users or those who will use it exclusively on model provider platforms, but setup is often complicated. Many users don’t bother, which is probably why model providers now offer marketplaces directly on their platforms. I haven’t set up a single MCP unless a client specifically asked me to; I simply use the API directly.

Don’t fall for the hype. Even using an older stack with previous-generation models and skipping the most advanced techniques, you can still make $Mn in revenue. Focus on the core problem your product solves, try to get users to pay for it, ignore the hype.

Things that did work

Here are the things that actually worked in this space.

Combining AI with a real-world use case!

Probably the single most important thing you can do is find a real-world business or problem and automate it with AI. As a technology partner, I had a front-row seat to the use cases that were actually profitable. Most major wins have been in boring, physically demanding businesses enhanced with AI.

Adding an AI layer to a truck repair service is more likely to succeed than developing a new AI memory system. AI has made tasks in the digital world easier, but the physical world remains challenging. Building AI tools for note-taking or spreadsheet replacements puts you in direct competition with companies like Anthropic or OpenAI. You can succeed, but the probability is lower, and model providers may use your telemetry data against you. Even major successes like Cursor face this problem — purely digital AI orchestration offers little moat.

Solve your problem first, then build a product!

So far, my company has launched five projects, but only two have generated meaningful revenue or attracted clients for productized services. Both of these started as personal automations that became products.

For AutoAnalyst, I initially built an AI data science coding and problem-solving agent to help me service clients faster, then later expanded it into a full platform. Blog2Video was an automation I built to create videos from my blogs and reach a wider audience. Both generate revenue passively and also bring in client inquiries for custom development.

If you’re a developer like me, I recommend automating as much of your work as possible with AI, then launching an MVP to see if people will pay. If you have a genuine solution to a real problem, people will pay — even if it’s half-baked, vibe coded, and looks AI-generated.

We’re different from our competitors because we have real, paying products that we build, manage, and market ourselves. If you’re looking for product-focused AI development, you won’t find a better fit.

Reach out here: https://tally.so/r/3x9bgo

Only listening to paid users

Seems obvious yet it isn’t taken seriously enough. Only listen to the people who are paying you for your product. Don’t listen to free users or product gurus. Just focus on paid users and their needs.

Everyone I know who is building products has made this mistake, they took every comment they got from a user/friend/peer and tried to “fix” it. Don’t!

In most cases even after fixing it, they will likely not convert. Your core ICP will pay for an unpolished solution, but non-core users will never pay.

Focus on paid users or people who have shown real intent to buy (like are paying for your competitors).

Conclusion

Here are the core lessons I learned from these past few years, hope to continue learning and grow. Please do subscribe, follow and share!

I started reviewing AI tools and writing about them a couple of months ago. This style of blog has been both successful and fun. Readers have really enjoyed my perspective and found it insightful.

Cursor was one of the first coding agents to gain mainstream popularity after Gavin. Anysphere, the company behind Cursor, is the fastest company to reach both $100 million ARR and $1 billion ARR. Needless to say, the tool is extremely popular and useful.

Coding agents have really heated up in the last couple of months, with Anthropic and OpenAI both launching their own AI coding assistants. That makes this the perfect time to share what I think about them as someone who has been building AI apps for over two years.

Watch the video version of this review:

Video made using:

Blog2Video

Overview

Lets start with a general and quick overview of what capabalities cursor really has. It is a customized version of the OSS IDE VSCode, popular among developers.

Tab

Tab is a Cursor model built for smart autocompletion. It learns from your choices — accept with Tab, reject with Esc — so suggestions get better over time. With Tab, you can:

• Edit multiple lines at once

• Auto-add missing imports

• Move across files for coordinated changes

• Get context-aware suggestions based on recent edits and linter feedback

Tab is one of the early features that helped Cursor gain traction but overtime newer features like Chat mode and Cmd+K got more usage.

Cmd + K

Cmd + K allows you to select a piece of code or a file and request cursor to make quick changes.

Chat

In the chat module, you’ve got 4 ways to interact:

• Ask — Get answers or explanations without changing your files.

• Plan — Maps out a full plan of changes, including a .md file and next steps.

• Agent — Acts directly on your request.

• Debug — Dives into errors using logs like a debug pro.

Now that we know what Cursor can do, let’s jump into the review challenge.

Review Challenge

In all my coding platform reviews, I have the system replicate one of my projects. For this challenge, I’ll prompt Cursor in an empty folder to replicate autoanalyst.ai.

We’ll use Composer 1.5 here — a unique model/agent exclusive to Cursor. If I went with Opus 4.6, people will argue that the heavy lifting is by Anthropic engineers not Cursor engineers/makers itself.

The implementation summary, after zero interventions

Now lets try out what it

Want both the speed of vibe-coding & the trust/reliability of actual software engineer? Hire me & my team for your next project. We have built over 20+ app, many in production for startups, $Bn companies & academics.

Reach out here: https://tally.so/r/3x9bgo

I asked it to visualize the data and tell me which houses (sample data is of housing) are important.

Initial Thoughts

• UI Experience: The user interface was not very well-designed or aesthetically pleasing.

• Functionality & Cost: Despite the UI issues, the system functions reliably. Compared to other platforms for “vibe coding,” it is relatively affordable — unless you go beyond the Pro plan limits.

• One-Shot Use: For single, focused tasks using their Composer model (which offers higher usage limits than Opus/Codex), it serves as a solid starting point.

Things I like about Cursor:

1. Model Optionality: Cursor offers a variety of models, including its own Composer model. This flexibility is a major reason I remain a long-term supporter. By contrast, switching to Claude Code would lock me into only Anthropic’s models.

2. Good UX: The Cursor team was among the first to nail a user-friendly experience for coding agents. Features like Tab autocomplete and Cmd+K made the tool feel engineered by developers for developers.

3. Speed & Familiarity: The system is generally fast and responsive, though performance varies by model. Choosing VSCode as the interface foundation was smart — most software engineers are already familiar with its workflow, reducing friction and improving productivity.

Thing I don’t like about Cursor:

1. Aggressive Pricing: Cursor is affordable only if you remain within the pro-plan limits, afterwards the costs scale quickly. I can understand why since they don’t own the model APIs they have to charge a premium. The number one complaint on r/Cursor is usually about how quickly costs scale after plan limits reached.

2. Unreliable Context switching: In my own use I found that the chat module does not switch context reliably enough. If I asked it to move from feature A to feature B it sometimes starts making changes again to feature A.

3. Auto model selection is useless: Auto is suppose to give you balanced model to get your tasks done. However, I almost never use it after trying it once or twice. Almost all changes by auto are not very good or balanced.

Cursor Wishlist:

1. Top tier Composer Model: Composer is good when you know what you are doing. However, it can’t compete with latest models made by Anthropic/OpenAI. I really wish they build the top tier competitor to gpt and opus.

2. Better UI builder: Depending on when you read this, they might have already fixed this. However, mostly the UI built by cursor is similar, it usually has that ‘made with AI’ feel. If they can ensure that their orchestrator can make a ‘different’ UI than most, it would be awesome.

Overall, cursor is a great tool. One me & my team use every day. I hope you enjoyed this review, please follow & subscribe

Want both the speed of vibe-coding & the trust/reliability of actual software engineer? Hire me & my team for your next project. We have built over 20+ app, many in production for startups, $Bn companies & academics.

Reach out here: https://tally.so/r/3x9bgo

Honest review of Lovable from an AI engineer
I tried lovable to build projects, and here is an honest reviewwww.firebird-technologies.com

We’ve been quietly building, and today we’re excited to share a wave of updates that make Blog2Video better in every way that matters.

For those new here — Blog2Video turns your blog posts into professional, ready-to-share videos in minutes. Paste a URL, pick a style, and let the platform handle the rest. No editing skills required.

Now, let’s talk about what’s changed.

You can watch the video version of this blog here:

Video version of blog made using https://blog2video.app

Four Stunning New Templates

4 templates, more to come

We completely redesigned our template system from the ground up. You now have four distinct visual styles to choose from:

• Geometric Explainer — clean, structured layouts perfect for educational content

• Nightfall — a dark, cinematic aesthetic for a more dramatic feel

• Gridcraft — warm editorial bento grids that give your video a magazine-quality look

• Spotlight — bold kinetic typography that puts your words front and center

Each template is crafted to give your videos a unique identity, not just a different color scheme.

Blog2video

Scene Editing That Actually Works

Editing both Manual and with AI

This is the one we’re most proud of. You can now edit every scene in your video — manually or with AI.

AI assisted editing

In manual mode, fine-tune titles, display text, and typography settings down to the font size. In AI mode, just describe what you want and the system rewrites and restructures the scene for you, including layout and voiceover. It’s the best of both worlds.

Blog2video

Full Image Control

Full Image control

Every scene now gives you complete control over its visuals. Remove an image you don’t like with one click, upload your own, or let the system auto-assign the best match. No more being stuck with an image that doesn’t fit.

Drag-and-Drop Scene Reordering

You can now shuffle and reorder scenes

Want to rearrange your video? Just grab a scene and drag it where you want it. The entire video updates instantly. It makes iterating on your story flow incredibly fast.

Reliability & Quality, Leveled Up

Under the hood, we’ve pushed render success rates to 99.9%, upgraded output to full 1080p HD, and cut processing time in half. Your videos render faster, look sharper, and never fail.

These updates are live now. Head to blog2video.app and see for yourself. If you’ve been waiting for the right time to turn your content into video — this is it.

Need your custom AI solution? We have delievered 20+ apps currently in production

Reach out here: https://tally.so/r/3x9bgo

Check it out at blog2video.app

Blog2video

I write blogs. I enjoy writing blogs. But let’s be honest — not everyone wants to read. Some people want to watch. So I asked myself: what if I could turn any blog post into a professional explainer video, without touching a video editor?

Turns out, you can. Here’s how I did it with Cursor, Remotion, and ElevenLabs.

Blog2Video

The Stack

1. Cursor — an AI-powered code editor. You talk to it, it writes code. Think of it as having a senior developer sitting next to you, except it never gets tired and never judges your variable names.

2. Remotion — a React framework for creating videos programmatically. Instead of dragging clips around on a timeline, you write React components. Each scene is a component. The video is just JSX.

3. ElevenLabs — AI voice generation. You give it a script, it gives you back a natural-sounding voiceover. No microphone, no recording studio, no “um”s.

Examples

Before I show you how to do this here are some examples of my blogs turned into videos

The Workflow

The whole process comes down to one prompt file and a conversation with Cursor. I built a master prompt (prompt.md) that encodes my entire video style — the branding, color palette, animation rules, project structure, and every lesson learned from previous videos. It’s basically a blueprint that tells the AI agent exactly how to build a Remotion project from scratch.

Then I just told Cursor: “Use prompt.md to create a video explainer for my Tally Forms review.”

Here’s what happened next:

1. Cursor read the blog and broke it into 7 logical scenes — intro, what is Tally, features walkthrough, likes, dislikes, AI wishlist, and outro.

2. It wrote conversational voiceover scripts for each scene. Not copy-pasted blog text — actual spoken-word scripts with natural pauses and flow.

3. It called the ElevenLabs API via a Python script to generate all 7 audio tracks. A British male voice (George) narrating the whole thing.

4. It built every React component — each scene with fade-in animations, screenshots from the blog, numbered lists, card layouts, and branded elements. All following the design system in my prompt file.

5. It measured the audio durations and wired up the exact frame timing so every scene matches its voiceover perfectly.

6. It launched the Remotion studio where I could preview the entire video in my browser.

The whole thing — scaffolding, scripting, audio generation, component creation, and timing — took one conversation.

What’s Inside prompt.md

The prompt file is around 650 lines and it covers everything the AI agent needs to produce a video end-to-end, without asking me follow-up questions. Here’s what’s in it:

1. Branding & Design System — The company name, logo file, tagline, and a full color palette (background, text, accent, muted, card fills, borders). It locks in two font families: JetBrains Mono for titles and code, Inter for body text. Every scene gets a subtle grid background that fades in with the scene.

2. Strict Animation Rules — Only opacity fade-ins are allowed. No translateX, no translateY, no scale, no rotate, no CSS transitions or keyframes. This single rule eliminates 90% of the janky rendering issues I hit in earlier videos. Elements stagger in with 30–40 frame gaps.

3. Project Structure — A complete directory tree so the agent knows exactly where every file goes: config files in the root, scene components in src/components/, audio in public/audio/, images in public/.

4. A 12-Step Build Order — Scaffold the project, copy assets, create configs, install dependencies, read the blog, plan scenes, write voiceover scripts, generate audio, measure durations, create components, wire up timing, and launch the studio. The agent follows this exact sequence every time.

5. Scene Component Patterns — Seven reusable layout templates: intro with banner image, numbered list, card layout, multi-column, results/data, pipeline/flow, and outro. The agent picks the right pattern for each section of the blog.

6. Voiceover Generation — A complete Python script for calling the ElevenLabs API, plus writing rules: conversational tone, double dashes instead of em dashes for TTS, spell out small numbers, keep each scene to 15–35 seconds.

7. Audio Duration Checker — A zero-dependency Python script that parses MP3 headers to get exact durations. The formula is simple: frames = audio_seconds × 30fps + 60 frame buffer. No guessing.

8. A Known Pitfalls Table — Fourteen specific bugs I hit in previous builds and the mandatory fix for each. Things like: mkdir -p fails on PowerShell (use New-Item instead), Unicode in Python print statements crashes on Windows (ASCII only), .webp images fail silently in Remotion (convert to .jpg first), spaces in filenames break path resolution (use hyphens).

9. Pre-Render Checklist — A final sanity check: all scenes use fade-in only, logo placement is correct, color scheme matches, audio files exist, durations are measured not guessed, TypeScript compiles clean.

10. The whole point of the file is that every mistake I made once is now impossible to make again. The prompt grows smarter with every video I build.

What Makes This Work

The secret isn’t any single tool. It’s the combination:

1. Cursor handles the complexity. It reads your blog, makes creative decisions about scene layouts, writes TypeScript, runs Python scripts, and debugs issues — all in one flow.

2. Remotion makes video programmatic. Every scene is version-controlled, reusable, and easy to tweak. Want to change a color? It’s one line. Want to swap an image? Just update the file path.

3. ElevenLabs removes the recording bottleneck. The voice sounds natural, and you can regenerate any line instantly if you want to adjust the script.

The Result

A ~2.5 minute explainer video with:

• 7 scenes with staggered fade-in animations

• 8 blog screenshots integrated across scenes

• Professional AI voiceover

• Consistent branding throughout

• Zero manual video editing

Could a professional video editor make something more polished? Absolutely. But could they do it in minutes from a single conversation? Probably not.

Don’t Want the Hassle? Use Blog2Video

https://blog2video.app

Look, I’ll be real — the setup I described above is powerful, but it’s a developer workflow. You need Cursor, Node.js, Python, an ElevenLabs API key, and the patience to maintain a 650-line prompt file. Not everyone wants that. If you just want to paste a blog URL and get a video back, check out blog2video.app. It does exactly what the name says — turns your blog posts into videos without any of the technical setup. No code, no prompt engineering, no debugging TypeScript at midnight.

I built the hard way because I like the control. But if you want the easy way, it exists.

Thank you for reading!

There are already many form builders in the market. Many of them have integrated AI features and claim to the smartest form in the market.

However, we found a clear gap in most smart forms, they actually added complexity but did not offer any solution. AI is there but it doesn’t do much, the old drag and drop UI is still the norm

Autoform is designed with simplicity in mind. It takes you from creating -> analyzing your responses in minutes. AI is not just a feature but the entire product!

AutoForm :

1. Creates forms using a simple prompt from the user

2. Use AI to add or edit any component

3. Uses AI to validate and analyze responses.

Demo

Below is a step by step demo of generating a product review survey using autoform.

Add components from a list of 21 input types

AI Analysis

One of our core features is the ability to analyze submissions and analytics from your form. The AI agent has access to your submissions, and the form analytics.

Autoform can do the following:

1. Generate forms instantly

2. Make any adjustments quickly

3. Analyze the submissions for you.

Interested in how the project evolves? Don’t forget to follow and also subscribe to our newsletter

Thank you for reading!

So, Tally Forms has blown up as one of the go-to form builders out there. People love it because it’s super clean and minimal. You can whip up a form without wanting to pull your hair out. But here’s the thing: no software is perfect, right? This blog is my honest take on Tally, the stuff they’re crushing and the areas where there’s definitely room for improvement.

But first a walkthrough of the product.

Video version of this post made using https://blog2video.app

Generate Forms, Capture leads in seconds using AI:

AI First Forms

What is Tally?

Tally Form

Tally has a unique way of building forms as a doc file. Instead of pick & drop style creation in most form builders in tally you can create a form by just typing, inserting components using / and @ to mention previous questions as reference.

Adding components in Tally

Example of how you can reference previous questions

You can also add conditional logic.

Requires user to answer how can we improve in case they set their experience below 5/10

Tally also offer post publish analytics and submission management.

Submissions are shown as a table

Submission analytics

Question wise drop-off analytics

There are other useful features like custom domains, password protected forms and emails for submissions.

Now you can create forms instantly using AI!

AI First Forms

What I like about Tally?

1. Design: It is what really sets Tally apart. It is not just about what the product can do but how it looks. Their forms are clean and modern, and design has always been one of their biggest strengths.

2. Easy and simple UI: The interface is also very easy to use. Before AI tools became common, most form builders relied on drag and drop editors with crowded screens and endless menus. Tally took a different approach and made the experience simple and distraction free.

3. Partial Submissions: This is only available on the paid plans, but it can save a lot of time. It lets you capture leads even if someone gets distracted or forgets to submit the form.

4. Collaboration: Being able to work together with a team makes a big difference, especially when you are trying to produce your best work.

5. Transparency: This is not a direct feature, but Tally stands out as one of the most transparent SaaS companies. They openly share their product roadmap and actively collect feature requests. That level of openness is a big plus and builds a lot of trust with users.

What I dislike about Tally?

1. AI features: Tally did roll out some AI features in beta to a small group of users, which was great to see. But things are moving really fast right now — these days, you can generate an entire form with a simple prompt. While Tally does have an MCP server, there’s no straightforward way to actually generate forms with AI or chat with submissions directly on the site, which feels like a missed opportunity.

2. Analytics: Tally’s analytics are pretty basic. That’s probably fine for a lot of users, but I (and many others) would love a more detailed breakdown. For example, seeing deeper cross-sections of how different users interacted with a form, where they dropped off, or how responses vary by segment would make the data far more useful.

3. No Image slideshow: No image slideshow is one limitation I noticed. In Tally, you can only add one image at a time and there is no option to create an image slideshow. This matters to me because I sometimes need to show multiple images, like client testimonials or comparisons, in a slideshow format.

AI Feature List

I am a AI engineer, who loves trying out new ways to integrate AI into existing SaaS.

This section elaborates on the above point on how Tally AI is lacking:

1. In App Chat: MCP servers are hard to set up for most users. I personally want a chatbot I can prompt to generate forms. Ask about my submissions and maybe ask it to make quick customizations/edits.

2. AI x Analytics: AI is a great analyst to work with. I am sure many users take form responses and give them to claude to analyze or build a custom dashboard. I think Tally could potentially integrate this in their forms.

Thank you for reading, please follow me and FirebirdTech for more on AI and products.

Try AI First Forms:

AI First Forms

Site.pro is an all-in-one website builder that enables individuals, businesses, and agencies to create, host, and manage professional websites, landing pages, and e-commerce stores — without coding. It combines an intuitive drag-and-drop editor with AI-assisted website creation, multi-language support, and built-in SEO tools, while also offering domains, email, and high-speed global hosting.

This post will first walk through how to get started with Site.pro, then provide an in-depth review of its website builder, e-commerce features, performance, and overall usability — highlighting what works well and where there’s room for improvement.

Note: The Site.pro team asked me to write this review and compensated me for my time. However, the opinions shared here are honest and my own, and they did not ask me to influence the review in any way.

Using Site.pro

First start with building a lead tracking form website.

Unlike most other site builders, Site.pro allows you to pick from a variety of pre-built templates.

After a few moments I have my lead tracker website

After making final touches to the website, you can share or publish the site to the world

You can visit the site I generated in under 5 mins here:

https://arslanshahid.free.site.pro/

For the sake of completeness lets now try a more another website idea and see how it goes. Below some other mockup sites I built with Site.pro!

Site.pro has over 200 templates for sites and use cases most people would want. Now I have given a general walkthrough of their app, now lets start with the review.

Things I liked about Site.pro

List of things I liked:

1. The drag-and-drop concept is something not all AI website builders have. Along with the direct edit capabilities, it works well

2. Import a website, they have this unique feature that allows you to “copy” from the front page of another website. This allows you to quickly replicate some of the design/aesthetics you like.

3. It gives a fast and straightforward website, which is functional based on templates. Those templates are not fixed but give an overall scope that the tool needs to build.

4. They have domain, hosting, and email — everything under one roof, which is convenient.

5. It doesn’t try to create gradient-based UIs at all, which is something unique. Gradients have become the telltale sign of AI-generated sites, while most of these templates could pass as simple, non-AI-generated websites.

6. Collaboration, they have built in collaboration feature which allows you to share and work along other users. Most site builders constraint you to build solo, while collaboration is probably the better way to do things.

Things I didn’t like about Site.pro

1. The UI is more old-school rather than modern. This might appeal to their target users, but I prefer more modern designs.

2. The tool is heavily templated, which makes it faster but, at the same time, constrains its capabilities. These templates are great for a small business owner who just needs a website for their local business. However, considering that many AI site builders are trying to add advanced functionality, this is limiting for a ‘power user’ like me.

3. All the websites generated have a similar structure for the pages and designs. Unlike other tools that can generate or attempt to generate new designs based on instructions, this tool cannot.

4. Although I like the concept of a drag-and-drop no-code builder combined with generative AI, there is a lot that can be done. I would prefer if the tool allowed the creation of entirely new components (not just predefined ones) and then let me place them on the site.

5. The AI chatbot could be drastically improved. It often falls back and tries to find a template for my query rather than generate something on the fly. The system currently feels more like a no-code tool with AI edit capabilities rather than a completely AI-powered site builder.

Site Builder Feature Wishlist

1. Flexible Component Creation: I would love the ability to create entirely new components from scratch, not just use predefined templates, and place them anywhere on the site. This would make the builder much more powerful for advanced users.

2. AI generated templates: It would be great if I could first define my template more concretely and then ask AI to implement it. Like I first define or plan a template then ask AI to generate.

Thanks for reading, if you like my product reviews, please do follow me on firebirdtech.

If you have a product I should review & share with my audience. You can reach out here: https://tally.so/r/81z09A

After testing our product Autodash — AI Data Apps, we discovered that most users aren’t just looking for standard dashboards. They want to personalize the experience deeply, treating data visualization as a form of art. Listening to their interests, we’ve added features designed to help them become true data artists, turning insights into visually stunning, highly customized creations.

Watch the video version of this post, made using https://blog2video.app:

Data visualization is an art form. We built a product that turns you into the data artist. Try it here:

AutoDash

Design Features

This blog post will walk through all the design features we introduced into the product.

Now users can change trace/line/bar/component colors directly, instead of asking it to regenerate the chart with a different color

The system auto-detects components generated in the visualization

Now users can change the chart/kpi card/text background and opacity as well; without regeneration or consuming credits

Pre-Image

User can also select a color for the dashboard as a whole, change opacity and also apply a two-color gradient

Pre and Post of entire dashboard background color change

We also develop custom AI SaaS products. We have done engagements with $Bn companies & early stage start-ups.

Reach Out

All of this combined with power AI data analytics abilities that help you get answer’s fast, uses Python’s data science libraries to find answers.

Design Features in pipeline

1. Preference Memory: We are internally testing a color and visual aesthetics-based memory system that will learn automatically what kind of colors/themes/charts you prefer

2. Themes: Every artist needs inspiration. We will give many professionally built visualization designs that will help users build amazing visualizations fast.

3. Fonts/Misc edit capability: Currently only main chart components are editable without regenerating the chart. We will give users the ability to change fonts, gridlines, and other misc. elements.

Analytics features in pipeline

1. Analytics Mode: A dedicated jupyter notebook like interface that allows users to build analytics pipelines quickly and easily.

2. Connectors: At the moment core support is for excel sheets and CSV. With SQL connectors available upon request. We plan to add all baseline data connectors to the system.

Thank you for reading. Autodash is the perfect tool for analytics done beautifully.

Banner for autodash.art

For the last two years, I’ve been working at the intersection of AI and analytics. It’s an exciting space — new models, new tools, and bold promises about “data-driven decision making.” But the deeper I went, the more something uncomfortable became obvious.

Small businesses are being left behind.

Most AI-powered analytics tools today are built for enterprises. They assume massive data volumes, dedicated data teams, and budgets that can justify months-long onboarding processes. They come with complex integrations, steep learning curves, and pricing that only makes sense if analytics is already a core function of your organization.

That’s fine for large companies.

But it completely ignores the reality of how most businesses actually operate.

The Overlooked Majority

Small businesses generate valuable data every single day.

Sales transactions. Marketing campaigns. Customer behavior. Website traffic. Operational metrics. Financial records.

The data is there — but the tools aren’t.

Most small teams don’t have data analysts on staff. They don’t have time to learn SQL, configure dashboards, or stitch together five different tools just to answer basic questions like:

• What’s actually driving my revenue?

• Which customers are most valuable?

• What changed this month compared to last?

• Where should I focus next?

Instead, they’re forced to guess.

And while enterprises get increasingly powerful insights, small businesses are expected to make critical decisions with spreadsheets, intuition, and fragmented reports.

That imbalance bothered me.

Try AutoDash

Why Existing Analytics Tools Don’t Work for Small Teams

The problem isn’t that small businesses don’t care about data.

The problem is that most analytics platforms weren’t designed for them.

They’re often:

• Too complex — requiring setup, configuration, and ongoing maintenance

• Too expensive — priced for enterprise budgets, not lean teams

• Too technical — built for analysts, not operators

• Too slow — insights take days or weeks to surface

For a small business, analytics shouldn’t feel like another full-time job.

It should feel like clarity.

Subscribe now

Building Autodash

That realization is what led me to build Autodash.

Autodash is built specifically for small businesses — teams that want answers, not complexity.

The goal was simple: make data analysis fast, understandable, and genuinely useful without requiring technical expertise.

With Autodash:

• There’s no complicated setup

• No integrations to manage

• No dashboards to design from scratch

You simply upload your data, and Autodash does the rest.

Try AutoDash

autodash.art

Have a use-case or product you want to build? We also build custom AI tools for clients

You can reach out here: https://tally.so/r/3x9bgo

What Makes Autodash Different

Autodash isn’t about showing you endless charts and metrics.

It’s about answering the questions you actually care about.

Here’s what you get:

1. Clear insights without complexity
   Autodash focuses on clarity, not clutter. You see what matters, not everything that’s possible.

2. AI-powered dashboards that explain your data in plain language
   Instead of raw numbers, Autodash tells you what’s happening and why — in words anyone can understand.

3. Shareable dashboards for your entire team
   Insights shouldn’t live in silos. Autodash dashboards can be shared so everyone is aligned.

4. No integrations required
   Just upload your data. That’s it.

5. Security first
   Autodash doesn’t store your data. Your information remains private and secure.

Dashboard example

Turning Data Into Decisions

Analytics shouldn’t be intimidating.

It should help you run your business better.

Autodash is built around a simple belief: small businesses deserve the same quality of insights as large enterprises — without the overhead.

When data is easy to understand, decisions get better.

When decisions get better, businesses grow.

That’s what Autodash is designed to enable.

There is currently a sale with 50% off till the New Year

Try AutoDash

We’re excited to introduce AutoDash, the lovable way to build beautiful data apps in seconds. While growing our previous AI data-science SaaS, we noticed a clear pattern: many users weren’t looking for another heavy analytics platform.

They wanted something fast, simple, and optimized specifically for Plotly dashboards. AutoDash is our answer, a streamlined, intuitive tool that lets anyone turn data into stunning, interactive dashboards instantly.

You can access the site here:

https://autodash.art

Feature Overview

In order to reduce complexity, the system creates a complete interactive analytics dashboard in just three steps:

Step 1: Connecting your data

Upload a csv or excel-sheets (tabular data only for now)

Step 2: Ask the AI to answer a specific analytics question

A text box you can tell what insights you want in the dashboard/data app

3. Generate Insights

Instant Insights

Use AutoDash

4. Edit & Add Charts

You can edit charts using the chat or edit button

Applying the results

Add Chart, either through chat or + button

Newly added chart

Get 40% off from autodash.art

Using this promocode at checkout: SUBSTACK

5. Do Analysis

Use AutoDash

5. Add notes to highlight important information

Notes to share your dashboard with colleagues and even the world

6. Publish to the world

You can easily host the dashboard for up to 24 hours for the free version & forever for the paid version

Shareable link available for 24 hours on the free tier & forever on the paid tier

Share your dashboard/insights with the world

Enjoy generating insights using our tool. We also provide specialized services for AI software solutions.

Have a use-case or product you want to build?

You can reach out here: https://tally.so/r/3x9bgo

Thank you for reading!

Tldr;

This blog post is a technical walkthrough of how we improved the coding agents used in the AI data scientist. With the actual data, and evaluation technique explained.

Watch the video version of this post, made using https://blog2video.app

It has the following portions:

1. Preparing data

2. Explaining GEPA

3. Applying prompt optimization (GEPA) via DSPy

4. Results

For a recap on the design of the system:

Preparing Data

The dataset is made up of python code execution runs done through our product. The auto-analyst is an AI system with multiple parts, each designed for a specific coding job. One part, the pre-processing agent, cleans and prepares the data using pandas. Another part, the data visualization agent, creates charts and graphs using plotly.

The system has about 12 unique signatures, each with two versions — one that uses the planner, and one that runs on its own for ‘@agent’ queries.

But for this blog post, we’ll focus on just 4 of those signatures and their two variants. These 4 alone make up around 90% of all code runs, since they’re the default ones used by almost everyone — whether they’re free or paid users.

1. preprocessing_agent

2. data_viz_agent

3. statistical_analytics_agent

4. sk_learn_agent

We can break the dataset down into two parts: the default dataset provided by the system and the data that users upload themselves.

Our goal is to make sure any optimization improves performance on both. It should work well not just on the default data but also on the datasets users upload.

To do this, we need to stratify the data. That way, the model doesn’t overfit on the default dataset and can handle a variety of inputs effectively.

Another important factor we need to consider is the model providers. We don’t want to optimize just for one provider and end up hurting performance on the others.

Note: There’s bias in this because our users mostly used OpenAI’s cheaper models like GPT-4o-mini in our system, while for Gemini our users used only their top models. Since we don’t have enough data to do the evaluation on a per model basis, we’re using the provider as a proxy. When comparing top OAI models with the top models of other providers, Openai’s success rate is similar.

After preparing the dataset, we created a stratified sample with the following constraints:

• No more than 20% of the data comes from the default dataset (is_default_dataset == True).

• Each of the three model providers (openai, anthropic, gemini) is represented in at least 10% of the final sample.

• Stratification was done across three columns:

• model_provider

• is_successful

• is_default_dataset

Once the stratified sample was created, we split it into a training set and a test set to be used for evaluation.

Looking for someone to implement AI evals and guardrails for you? Or to improve your AI system?

Reach out for help here: https://tally.so/r/3x9bgo

Explaining GEPA

GEPA stands for (Generic-Pareto) is an evolutionary prompt optimizer designed for DSPy programs that uses reflection to evolve and improve text components such as AI prompts. GEPA leverages large language models’ (LLMs) ability to reflect on the program’s execution trajectory, diagnosing what worked, what didn’t, and proposing improvements through natural language reflection. It builds a tree of evolved prompt candidates by iteratively testing and selecting better prompts based on multi-objective (Pareto) optimization.

Step-by-step, here is what GEPA does as an evolutionary prompt optimizer in DSPy:

1. Initialization:

• GEPA receives inputs: a compound AI system (with prompts/modules to optimize), a training dataset, an evaluation metric, a feedback function, and a rollout budget.

• It initializes a candidate pool with the base system as the first candidate and splits the training data into feedback and Pareto evaluation sets

2. Evaluation of Initial Candidates:

• Each candidate system is evaluated on the Pareto set, producing a set of scores reflecting performance on different task instances.

3. Iterative Optimization Loop:

• GEPA repeatedly executes until the rollout budget is exhausted:

• a. It selects a candidate from the current pool, focusing on those along the Pareto frontier (non-dominated candidates).

• b. It chooses a module (a prompt segment) within the selected candidate to optimize.

• c. Runs the candidate system on a minibatch of feedback data, collecting detailed feedback including outputs, scores, traces, and diagnostic information.

• d. Uses a large language model (reflection LM) to analyze this feedback and reasoning chains in natural language, trying to identify what worked, what failed, and how to improve the prompt.

• e. The LM proposes an improved prompt for the selected module by mutation and textual refinement.

• f. The system creates a new candidate by replacing the old module with the improved prompt.

• g. It evaluates the new candidate on the minibatch to check if performance improves.

• h. If improved, the new candidate is added to the pool and evaluated on the full Pareto set, updating the candidate pool and parent-child relationships.

3. Candidate Selection:

• Selection favors candidates on the Pareto frontier to promote diverse high-performing solutions.

• Stochastic selection is used to explore promising candidates more frequently.

4. Continuation and Convergence:

• The process continues iteratively, accumulating improvements over generations.

• It builds a tree of evolved prompt candidates showing the optimization trajectory.

5. Output:

• The best-performing evolved candidate prompt configuration is returned after the budget is exhausted.

• This final prompt outperforms the base prompt significantly, as shown in benchmarks like AIME math problems.

In summary, GEPA uses LLM-based reflective natural language reasoning on prompt execution feedback to evolve prompts via an evolutionary algorithm with Pareto optimization, while being constrained by a budget.

Here are some resources for an Indepth technical introduction to the concept:

1. Original Paper: https://arxiv.org/pdf/2507.19457

2. Videos by Connor Shorten:

1. DSPy implementation guide: https://dspy.ai/api/optimizers/GEPA/overview/

Applying GEPA to Auto-Analyst — a practical example

The autoanalyst and its components are already defined as DSPy modules and signatures.

Since we don’t store user datasets (by policy), the only information available is the context passed to each agent. To work around this, we need to recreate a “mimic” dataset with the same columns, inferring data types from the descriptions.

An LLM can then be used to generate synthetic dataset context, which we can wrap into a dummy data frame for execution.

class create_synthetic_context(dspy.Signature):
    “”“
    You are tasked with generating a synthetic pandas DataFrame that mimics a user’s dataset. 
    The dataset should be inferred from the agent’s code and the provided error message, 
    since the real user dataset is unavailable.

    Instructions:
    - Carefully analyze the `code` and `error_message` to identify what columns, datatypes, or shapes the dataset likely has.
    - Identify the DataFrame variable name from the code (e.g., df, data, customers, train_data). 
      Use that same variable name in your output instead of always defaulting to `df`.
    - Infer column names from any DataFrame references (e.g., data[’age’], customers[”salary”], train_data[”city”]).
    - Infer datatypes based on column names and context:
        - If numeric (e.g., “age”, “salary”, “score”, “amount”), use integers or floats.
        - If categorical (e.g., “gender”, “city”, “department”), use short string categories.
        - If datetime-related (e.g., “date”, “timestamp”, “year”), generate pandas datetime values.
        - If ambiguous, default to strings.
    - Generate at least 10–15 rows of data, with varied values (not all identical).
    - The dataset should be syntactically valid Python code that defines a pandas DataFrame.
    - The output must be directly executable with pandas (no pseudocode).
    - Ensure reproducibility by including the imports (`import pandas as pd` and `import numpy as np` if needed).
    - Do not include explanatory text — only return runnable Python code that creates the dummy dataset.

    Goal:
    Provide a realistic dummy dataset that allows the agent’s code to run for evaluation, 
    even though the original user dataset is not available.
    “”“

    code = dspy.InputField(desc=”The code generated by the agent”)
    error_message = dspy.InputField(desc=”The error message generated by the code”)
    dummy_dataset = dspy.OutputField(desc=”Synthetic dataset python code (pandas df) with same columns and inferred datatypes that mimics the original, to be used for evals”)

GEPA requires us to define a `metric_with_feedback` function. Which both computes a numeric number to tell what score our answer got and also gives text description.

Since, these are coding agents we would atleast want the code to be executable. Next we would want the code to be detailed and relevant to the original goal (query).

#Feedback metric designed for GEPA
def metric_with_feedback(example, prediction, trace=None, pred_name=None, pred_trace=None):
    data_maker = executions.iloc[example.index][’dataset_maker’]
    score = 0
    feedback_message =”“
    try:
        exec(sanitize_for_exec(data_maker))
        exec(sanitize_for_exec(prediction.code))
        score+=1
        feedback = dspy.Predict(”code,goal->code_detail_and_relevance_score:Literal[1,2,3],feedback_for_improvement:str”)
        
        feedback_message = feedback(code=prediction.code,goal=example[’goal’])
        try:
            score+= int(feedback_message.code_detail_relevance_score)
        except Exception as e:
            raise “cannot convert to string”
        
    except Exception as e:
        feedback = dspy.Predict(”failed_code,goal,error->feedback_for_improvement”)
        feedback_message = feedback(failed_code=prediction.code,goal=example[’goal’], error=str(e)[-200:])
    
    return dspy.Prediction(score=score, feedback=feedback_message.feedback_for_improvement)

Next we need to initialize the signatures for all of the agents we want to improve, and we already have planner outputs from the executions, which will allow us to direct the flow of the query to each of the agents.

preprocessing = dspy.Predict(preprocessing_agent)
sk_learn = dspy.Predict(sk_learn_agent)
data_viz = dspy.Predict(data_viz_agent)
statistical_analytics = dspy.Predict(statistical_analytics_agent)

Next we need to construct examples based on the inputs of the system and feed to the GEPA optimizer. You can see all the options available in dspy.GEPA API here: https://dspy.ai/api/optimizers/GEPA/overview/

from dspy import GEPA

optimizer = GEPA(
    metric=metric_with_feedback, # the feedback function we defined
    auto=”light”, # auto budge for the run
    num_threads=32,
    track_stats=True,
    reflection_minibatch_size=3, # the reflection size
    reflection_lm=dspy.LM(model=”gpt-4o”, temperature=1.0, max_tokens=5000) #LLM for reflection component
)

optimized_program = optimizer.compile(
    agent_system, # Replace this with whatever dspy Module you are optimizing
    trainset=train_set,
    valset=val_set,
)

Results

After running the program for the four agent’s we got new instructions for each.

Here is the new data_viz_agent prompt

You are a data visualization agent designed to generate effective visualizations based on user-defined goals and specific datasets provided in a structured format. Your enhanced responsibilities and necessary details for best practices are as follows:

### Input Format:
1. **Dataset**: Provided in JSON or Pandas DataFrame format, detailing its structure and attributes, including column types, preprocessing requirements, and guidelines on handling missing values.

2. **Goal**: A clear statement that defines the analytical objectives for visualization (e.g., performance analysis, relationship discovery, or data clustering).

3. **Plan Instructions**: Specific directives from an analytical planner regarding analysis creation, dataset usage, and additional plotting notes.

4. **Styling Index**: Contains visual preferences for the plots, axis specifications, formatting requirements, and any template references.

### Responsibilities:
1. **Data Handling**:
   - Confirm the presence of necessary data variables before proceeding.
   - If datasets exceed 50,000 rows, sample them down to 5,000 rows for efficiency.
   - Check for missing values in crucial columns and address them according to preprocessing instructions (e.g., mean or median imputation).
   - Ensure that columns have consistent lengths, especially those involved in calculations.

2. **Visualization Creation**:
   - Utilize Plotly and Matplotlib for visualization, focusing on user-defined goals and creation instructions from the plan.
   - Generate multiple relevant visualizations based on specific goals, potentially including bar charts, histograms, scatter plots, word clouds, or heatmaps as dictated by the task requirements.
   - Implement text processing techniques for natural language data (e.g., removing special characters while preserving language integrity).
   - For datasets comprising categorical variables, ensure they are handled correctly, including appropriate encoding of categorical features and filling in missing data with default categories.

3. **Layout and Styling**:
   - Follow the provided styling index for clarity and aesthetics, ensuring cohesive axis formatting and color usage.
   - Use `update_yaxes` and `update_xaxes` for effective axis presentation, maintaining a uniform look across visualizations.

4. **Error Handling**:
   - If essential variables are missing or if there are mismatched array lengths, return clear error messages indicating the specific issues (e.g., “DataFrame not defined,” “Column missing”).
   - Address any ambiguities in input formats and expectations proactively rather than making unfounded assumptions.

5. **Output**:
   - Visualizations must be displayed using the appropriate methods such as `.show()` or `fig.to_html(full_html=False)` for seamless HTML rendering.
   - Each visualization should include comprehensive legends or annotations where applicable, helping to clarify complex data stories.

### Domain-Specific Considerations:
- **Text Data**: When handling natural language data, particularly in non-English languages, use regular expressions to efficiently clean and preprocess text while preserving linguistic characteristics. This includes maintaining sentiments or specific keywords.
- **Performance Metrics Analysis**: For performance-related KPI analysis, include methods for detecting outliers and normalizing scores to facilitate comparisons across different datasets or campaigns.
- **Word Cloud Creation**: When generating word clouds, ensure to create distinct visual representations for different categories (questions vs. answers) and apply suitable color schemes to enhance differentiation.

### Performance and Clarity:
- Clean and preprocess data according to the details provided in the input descriptions.
- Aim to visualize insights simply and clearly, emphasizing ease of understanding.
- Strictly adhere to any specific instructions from the styling index, keeping the target audience’s comprehension in mind when designing visual representations.

There are new additional specs for Domain-Specific Considerations and Performance & Clarity. Next is the new prompt for statistical_analytics_agent.

You are tasked with performing statistical analysis on datasets based on provided structured inputs. Ensure comprehensive results by following these detailed instructions carefully:

### Input Format:
You will receive structured input, which includes:
1. **Dataset Description**:
   - Overview of the dataset, including its purpose and key columns (types, etc.).
   - Specific preprocessing instructions for each column, particularly for data type conversions and missing value handling.

2. **Analytical Goal**:
   - A clearly defined goal, such as generating specific insights, performing calculations, or summarizing the data.

3. **Plan Instructions**:
   - Detailed actions that should be taken, outlining what variables to create, which existing variables to use, and any other necessary processing steps.

### Key Responsibilities:
1. **Data Preprocessing**:
   - Inspect columns for needed preprocessing according to the dataset description provided.
   - Implement preprocessing as specified, including handling categorical variables with appropriate encoding (e.g., one-hot encoding).

2. **Statistical Analysis**:
   - Conduct analysis based on the defined goal, which may involve:
     - Descriptive statistics (means, medians, etc.).
     - Correlation analysis to understand relationships among numerical variables.
     - Calculation of specific metrics described in the task.
   - Utilize libraries such as `pandas` for data manipulation and `numpy` for numerical operations.

3. **Output**:
   - Results must be presented in a structured and organized text format, integrating all specified variables into the final report.
   - Avoid creating any intermediates that are not specified in the plan instructions.

4. **Error Handling**:
   - Integrate error checks to confirm that all requisite variables are well defined and valid prior to executing operations.
   - Address edge cases, including situations where DataFrames may be empty or lack the necessary columns.

5. **Documentation**:
   - Summarize all findings succinctly, detailing:
     - Key statistical outcomes, highlighting identifiable trends or relationships.
     - Potential data quality issues, such as missing values or outliers.

### Analytical Methodology:
- Always start with data cleaning, ensuring that missing values are handled as specified (e.g., filling with mean or median) and outlier checks are sufficient.
- When performing statistical analysis, use measures that facilitate understanding of data distributions, such as means, medians, and standard deviations, as well as categorizations based on quantitative thresholds.
- Implement segmentation strategies based on calculated scores, specify the thresholds clearly for different segments, and ensure that insights can lead to actionable outcomes.
- Include plots where required, and ensure they are prepared in a separate stage, if indicated in the plan.

### Important Notes:
- Do not modify data indexes unless instructed; maintain the integrity of the dataset structure throughout.
- Ensure all numerical data is converted to the appropriate types prior to analysis.
- In the event that visualizations are indicated, prepare these in a separate task as per the capabilities outlined.

By adhering to these instructions meticulously, you will deliver consistent and high-quality analytical insights tailored to the provided datasets.

In a similar way preprocessing agent and sk_learn agent both got new prompts.

Now let’s evaluate the performance of the system as a whole.

The performance delta is 4% for default dataset and 8% for custom datasets.

Note: However, this is still based on our test data, we would be testing on live data to determine the real impact of the optimization.

Thank you for reading, please follow and share if you like technical content involving AI.

The autoanalyst is an open-source AI data scientist developed by Firebird technologies. The project was in live beta since May 14, 2025. As of writing this post ~900 people have signed up the beta version, with over 2,000 queries asked by our users.

Since our initial launch, we've been closely observing how users interact with the system to better understand where we can improve. While we don’t claim to have a full picture of every user's needs, some clear patterns have started to emerge.

In this post, we’ll highlight the latest features we've rolled out and share a glimpse into where the project is headed next.

Subscribe now

Usage Patterns

After looking into the data (no pun intended) we found that the most common use for the product is visualizations. That fact did not seem to come as a surprise (we were expecting that) but what was unexpected was how much data visualization task’s dominate overall usage.

Our data suggests that more than 80% of queries requested visualizations explicitly!

So, in order to serve our user’s better we have added visualization-based features!

Many users complained that while they appreciated the visualizations generated by the system, they were unable to save them or view them in full-screen mode. Users also wanted to compare different & contrast different charts for analysis.

Need a builder that is in the trenches like you? I provide AI development services to clients. So far have done 13+ engagements with scrappy startups to MNCs.

Reach out here: https://tally.so/r/3x9bgo

To make things easier, we’ve added a full-screen view option so you can focus on your charts without distractions. There’s also a new Dashboard view in the sidebar, where you can quickly pin any charts you want to save or compare later.

On the backend, we’ve made a big upgrade to our planner system; it’s now much more likely to recommend the visualization agent, helping user’s “see” the analysis they are doing.

Overall, directionally we will make visualization’s the most polished & refined feature of the product.

Multi-Sheet support for Excel

We’ve added support for multi-sheet simultaneous analysis! The system now automatically builds the context needed to make everything work smoothly.

From there, the planner decides which datasets to use for each query and gives clear instructions to each agent on how to handle their part.

Polished UI

Here are some improvements we made to the UI

Also, the dashboard view, where you can view all your pinned charts

Future direction

The project has come a long way from the start. A few months back it was just a streamlit app.

While we’ve made great progress, there’s still a lot more to do. We’re committed to learning from our users and continuously improving the experience. If you have thoughts or suggestions, we’d love to hear them — just use the feedback tab at the top of the screen to share your input anonymously.

Based on the data and feedback we’ve gathered, here are some of the key features we’re planning to add next:

• A notebook-style interface to complement the current chat-based setup.

• Better visualization tools, including the ability to share charts directly on social media.

• More responsive and reliable AI performance. Building with LLMs is challenging — especially when it comes to balancing reliability and cost. We’ve already fixed many issues, but there’s more to address, and we’re focused on making the experience as smooth and dependable as possible.

• Additional data connectors. Right now, the hosted version supports only CSV and Excel files, but we’re working on expanding that. For enterprise customers, our on-prem deployments already support custom connectors.

Need a builder that is in the trenches like you? I provide AI development services to clients. So far have done 13+ engagements with scrappy startups to MNCs.

Reach out here: https://tally.so/r/3x9bgo

Stay tuned — there’s a lot more coming!

Subscribe now

A few weeks back we shared our idea for an AI powered SQL trainer and asked people to fill out a short form if they were interested. The responses made it clear that most bootcamps are charging way too much just to teach SQL and basic analytics. That is why I am excited to share that SQLTrainerAI is now live in beta, the first step toward making analytics learning accessible online with an AI powered instructor.

Long term, based on how far this project goes, we might add more features and other languages / skillsets. This post is a general walkthrough over what we have built so far!

Link:

https://sqltrainerai.com

You can use this promocode at checkout to get a 20% discount.

Promocode: FIREBIRDTECH

Walkthrough

There are two modes of learning for available to the user. One is competitions with our Text2SQL agent and the other are self-serve practice sessions.

Competitions

The purpose of this mode is to make learning SQL competitive & fun. You will be competing with a text2SQL agent with three settings.

Basic: Where the agent uses a lower tier model & has a block system that nerfs it’s powers and makes you more competitive.

Intermediate: The agent uses a higher tier model, and has better access to the schema docs, making it more challenging to compete against. The block system still exists but is not as prohibitive as in Basic.

Hard: The agent has access to most advanced models, schema docs and the block system is nerfed further. Don’t worry we purposefully ensured that human’s remain competitive with AI.

At the end of every competition, you get a certificate of points versus the AI.

At the end of the competition, you get a final report that shows what you got right vs wrong

At the end you get a certificate that tells how well you did. You can use these as proof of how good you are at SQL.

Practice

The second learning mode is practice, in which you generate a schema & answer ten questions. Again you have three modes of difficulty. Basic, intermediate & difficult. You can also choose your preferred topic to learn.

You can simulate any schema for example for a job in a e-commerce site you can ask it to generate a schema for an online store.

At the end of every session, you get a certificate for how well you did and overall accuracy.

Master certificate

The master certificate is a prized reward for practicing a lot on our app. To get it you complete multiple basic, intermediate & advanced practice sessions.

Why our certificates are legit?

This question is at the heart of the value we provide.

Our certificates are legit because they’re based on verifiable, hands-on skill demonstration rather than rote memorization.

Unlike traditional bootcamps that recycle the same test banks and allow answers to be found online, SQL Trainer AI generates unique schemas for every session, executes queries against real databases, and validates results for accuracy.

The system also analyzes problem-solving approaches and adapts continuously, ensuring learners can’t simply copy answers but must actually demonstrate mastery.

This makes our certification a true reflection of practical ability, not just theory.

We do recognize that as a new project, it has zero legacy credentials but overtime we at firebird believe that online AI based analytics training will be as reputable as many major brand names.

Thank you for reading!

Link: https://sqltrainerai.com

You can use this promocode at checkout to get a 20% discount.

Promocode: FIREBIRDTECH

To stay updated with our projects follow & subscribe:

Linkedin: https://www.linkedin.com/company/firebird-technologies-singapore

Substack: www.firebird-technologies.com

Sankey diagrams are used to visualize flow or processes, as the above image shows how many transitions/flow between different customer segments. The specific business problem was to see in 6 months which customer segment is growing, or shrinking and how are customers switching month on month. There are three customer segments low value (red), medium value (yellow), and high value (blue). This particular visualization helps see segment-wise growth, shrinkage, and transitions.

Examples of customer segmentation are widespread but Sankey diagrams could be used to visualize much more. Common business analytics use cases (by no means exhaustive) include:

1. Customer Journey: Customer journeys detail how the customer interacts with a product. Sankey diagrams can be used to visualize the whole journey for example visualizing how the customer interacts with your mobile application, which menus they visit, which buttons they click, and which channels they use for purchases.

2. Customer Lifecycle: Seeing customer behavior from first purchase to churn can help identify problems with retention/growth. You could also use it to see how customer lifetime value evolves.

3. A/B Testing: Visualizing how a particular experiment between different features changes customer metrics.

4. Product Recommendations: Detailing the performance of a product recommendation system or algorithm, and how different recommendations are performing based on business KPIs.

It is easy to see how Sankey diagrams are useful. The first step to learning anything is to get the basics working, then abstract and generalize to solve more complex problems.

Looking for someone to solve your problem? Click here:

How to Sankey - Basic

To understand how to implement first construct a simple Sankey. With three nodes and 6 links. In Plotly Sankeys are defined by three lists, if you can configure them properly, most of your work is done.

The three lists are source, target, and values. Plotly indexes each node using a number starting from 0 to the total number of nodes minus one. The source and target list define a link between nodes. To understand better let us look at the code:

#Importing the plotly graph object library
import plotly.graph_objects as go

#Creating the Sankey figure
fig = go.Figure(data=[go.Sankey(
#Basic styling options
node = dict(
 pad = 15,
 thickness = 20,#Tells the width of the node
 line = dict(color = “black”, width = 0.5),#Node border settings#(width & color)
 color = “blue”#Node color 
 ),
#Main attributes are the lists, if you have these figured out you #can make a Sankey.
link = dict(
 source = [0,0,1,1,2,2],#Contains info of origin of link
 target = [2, 1,0,2,0,1],#Contains info about which link to join
 value = [1,1,1,2,1,1]#Contains relative sizes(width) of links
 ))])
#Adding a title & showing the figure (Optional)
fig.update_layout(title_text=”Basic Sankey Diagram”, font_size=10)
fig.show()

I would highly encourage you to try different configurations manually to figure out how the diagram would change. Try adding more nodes and more intricate links etc.

The hardest part is configuring these three lists, other than that you just have to style your Sankey to make it look fancy. For small Sankeys configuring these lists can be done manually but it is hard to do when you have say 30 nodes and 100+ links. You often have to deal with customer-level data sets with multiple groups and categories to link. In the next section, we would start building our Sankey using simulated data of 1 million customers (link to the dataset).

Quickly make your own website:

Lovable

How to Sankey — Advanced

1. Data Wrangling

Starting from building the data for the visualization you’ll need basic knowledge of pandas, or other data manipulation libraries. Nothing too complicated, basic knowledge of groupby, lists, and dictionaries would suffice.

We will start by defining our end goal since there are three categories of customers (low, medium, and high value) and 6 months, which translates into 3 x 6 = 18 nodes. In our problem, our customer can switch segments month on month. Going from every category to every category is technically possible which makes a total of 3 x 3 = 9 links every month or a total possible of 6 x 9 = 54 links in the entire diagram. First, we have to groupby every month and then create aggregates month by month (first month with the second month, the second month with the third month, and so on).

#groups has all the combinations of 6 months
groups = df.groupby([‘First Month’,’Second Month’,’Third Month’,’Fourth Month’,’Fifth Month’,’Sixth Month’]).agg({‘Customer_id’:’count’}).reset_index()

#first_month has all the combinations of 1st Month with 2nd Month
first_month = groups.groupby([‘First Month’,’Second Month’]).agg({‘Customer_id’:’sum’}).rename({‘Customer_id’:’counts’}).reset_index()
#second_month has all the combinations of 2nd Month with 3rd Month

second_month = groups.groupby([‘Second Month’,’Third Month’]).agg({‘Customer_id’:’sum’}).rename({‘Customer_id’:’counts’}).reset_index()
#third_month has all the combinations of 3rd Month with 4th Month

third_month = groups.groupby([‘Third Month’,’Fourth Month’]).agg({‘Customer_id’:’sum’}).rename({‘Customer_id’:’counts’}).reset_index()
#fourth_month has all the combinations of 4th Month with 5th Month

fourth_month = groups.groupby([‘Fourth Month’,’Fifth Month’]).agg({‘Customer_id’:’sum’}).rename({‘Customer_id’:’counts’}).reset_index()
#fifth_month has all the combinations of 5th Month with 6th Month

fifth_month = groups.groupby([‘Fifth Month’,’Sixth Month’]).agg({‘Customer_id’:’sum’}).rename({‘Customer_id’:’counts’}).reset_index()
#list_ contains all these dataframes

list_=[first_month,second_month,third_month,fourth_month,fifth_month]

There are plenty of ways to do this but I prefer to create lists and dictionaries which ultimately define our three lists (source,target, and value).

#names contains all the labels of our nodes. We will add suffix #'_M1,_M2,_M3....' to our segmentation to differntiate one months #segement with other months,i.e LOW VALUE CUSTOMER_M3 tells Low #value customer in 3rd month. 

names = []
count_dict = {} #will contain all info of value list
source_list = [] #will contain all info of source
target_list = [] #will contain all info of target

for i in range(0, len(list_)): 
   cols =list_[i].columns # contains columns for our dataframe 
#(list_[i]) 
 #This for loop is inside the outer loop
 for x,y,z in zip(list_[i][cols[0]],list_[i][cols[1]],list_[i][cols[2]]):#Iterates over x(source),y(target),z(counts)
        
        if(x+'_M'+str(i+1) not in names):
            names.append(x+'_M'+str(i+1))#appends in names

#the next line is outside the if but inside the second loop

        count_dict[x+'_M'+str(i+1),y+'_M'+str(i+2)] =z
        source_list.append(x+'_M'+str(i+1))
        target_list.append(y+'_M'+str(i+2))

#Now we add labels into name for the last month targets
for v in target_list:
    if v not in names:
        names.append(v)

The above code snippet is complicated, but essentially what it does is maintain a names list with all the nodes labels, a source_list with all the source labels, target_list with all the target labels, and a count_dict which stores how much value does each source, target pair have.

Notice: Plotly requires indexes (0,1,2…) in the three lists, not labels but I stored the labels not indexed value in these lists because that way you can easily see if you have made an incorrect combination. if I began with indexes instead of labels it will be harder to debug. Now the next step is to assign a numeric value to each label.

#all_numerics contains the index for every label
all_numerics = {}
for i in range(0,len(names)):
    all_numerics[names[i]] = i

If you implemented this correctly you will have 5 things:

1. names: a list of all labels in source & target

2. source_list: a list of all source labels.

3. target_list: a list of all target labels

4. count_dict: a dictionary of all the counts, with two keys one for the source and one for the target.

5. all_numerics: a dictionary of an index value assigned to a label.

2. Plotting

fig = go.Figure(data=[go.Sankey(
 node = dict(
 thickness = 5,
 color =’blue’,
 ),
 link = dict(
#use all_numerics to transform labels to index
source = [all_numerics[x] for x in source_list],
target = [all_numerics[x] for x in target_list],
#Use count_dict to get value for each link
value = [count_dict[x,y] for x,y in zip(source_list,target_list)],
),)])
#Adding title, size, margin etc (Optional)
fig.update_layout(title_text="<b>Customer Segmentation</b><br>Month on Month", font_size=15,width=1200,height=800, margin=dict(t=210,l=90,b=20,r=30))
fig.show()

3. Styling & Annotations

We need to be able to differentiate between our different segments. For this essentially we will use a different color for each category.

#define two sets of color dictionaries one for the nodes and the #other for the links

#Node color dict, RGBA means red,green,blue,alpha. Alpha sets the #opacity/transperancy
color_dict = {'LOW VALUE CUSTOMER':' rgba(252,65,94,0.7)','MEDIUM VALUE CUSTOMER':'rgba(255,162,0,0.7)','HIGH VALUE CUSTOMER':'rgba(55,178,255,0.7)'}

#link color dict.The colors are the same but lower a value, lower #opacity. Gives a nice effect.

color_dict_link = {'LOW VALUE CUSTOMER':' rgba(252,65,94,0.4)','MEDIUM VALUE CUSTOMER':'rgba(255,162,0,0.4)','HIGH VALUE CUSTOMER':'rgba(55,178,255,0.4)'}

#Plotting, everything is the same as last with added colors

fig = go.Figure(data=[go.Sankey(
    node = dict(
      thickness = 5,
      line = dict(color = None, width = 0.01),
     #Adding node colors,have to split to remove the added suffix
      color = [color_dict[x.split('_')[0]] for x in names],),
    link = dict(
      source = [all_numerics[x] for x in source_list],
      target = [all_numerics[x] for x in target_list],
      value = [count_dict[x,y] for x,y in      zip(source_list,target_list)],
      #Adding link colors,have to split to remove the added suffix
      color = [color_dict_link[x.split('_')[0]] for x in target_list]
  ),)])

Lastly, to add annotations, you can use the add_annotations command or pass labels into the node dict while plotting in plotly. However, I prefer to annotate using PowerPoint or an image editor because add_annotations is tricky to use as you’ll need precise values for each annotation. The add labels method has a styling problem, you can’t change the color for every label. It only allows for one default setting for all labels. Nonetheless, here is the code for adding annotations.

#Adds 1st,2nd month on top,x_coordinate is 0 - 5 integers,column #name is specified by the list we passed
for x_coordinate, column_name in enumerate(["1st<br>Month","2nd<br>Month","3rd<br>Month","4th<br>Month",'5th<br>Month','6th<br>Month']):
    fig.add_annotation(
          x=x_coordinate,#Plotly recognizes 0-5 to be the x range.
        
          y=1.075,#y value above 1 means above all nodes
          xref="x",
          yref="paper",
          text=column_name,#Text
          showarrow=False,
          font=dict(
              family="Tahoma",
              size=16,
              color="black"
              ),
          align="left",
          )
#Adding y labels is harder because you don't precisely know the #location of every node.
#You could however add annotations using the labels option while defining the figure but you cannot change the color for each #annotation individually 

This concludes the article I hope you enjoyed learning how to make a Sankey Diagram. Please do consider following me and subscribing to my newsletter. I regularly post regarding data science, which includes the whole shebang from visuals to mathematics. Here are some of my articles that you will enjoy.

Lovable is an online AI-based website creator that allows you to build websites from scratch using just prompts and no code. For this review, I will try to recreate my projects using lovable.dev and see how far I can take them without coding myself.

Here is my affiliate link to sign-up to lovable (it won’t cost you extra, but I would get rewards if you sign-up using this link):

Try Lovable

The project I would try to replicate here is the autoanalyst!

Watch the video version of this post, made using https://blog2video.app

Replicating the Auto-analyst

Here is how lovable began building an autoanalyst clone.

It began by building the ‘planner’ and then adding other components. Finally, it creates a full one-page app with these features:

Now let’s see how it looks like:

I selected one of the sample datasets, and asked it to visualize:

It looked impressive, wow. But as I play further I realized that it always responds with the same chart! So, it has just saved that graph and launched it.

The auto-analyst is a white interface, so I asked it to change it.

I also asked to integrate OpenAI API, and also attach a database using Supabase. After adding in all the details, i.e. making the tables & adding my own OpenAI API key.

Instead of fixing the work app to look more like a chat interface, it made it into a blocklike structure with a chat input.

I tried to ask it to make the agents functional, but it simply was not able to do so, It also moved the chart output space underneath, which I never requested.

It became more and more obvious that my end goal of replicating the AI data scientist is not possible with lovable without me manually intervening to code where it left off.

You definitely need an AI engineer/software engineer.

Reach out here: https://tally.so/r/3x9bgo

Review

I was disappointed that just using the chat prompt, it didn’t even come close to solving my problem, which obviously requires an actual engineer like me.

However, all hope is not lost. It can’t replicate full-fledged apps, but it can definitely do somethings (I will be using it for):

1. Visualization Apps: As a data science consultant I have used streamlit and other low-code tools to build quick dashboard for my clients to play around with. This is definitely a step ahead of those, as a typescript frontend is more visually appealing.

2. UI components: I like the overall aesthetic design of some UI components, lovable can easily give me those to add to my existing projects.

3. Miscellaneous Tools: I often need to make small tools to make myself more productive, like a social media poster, contact list etc. It was easy to attach a database using supabase, which is a feature I really like.
   

What I want in a tool like lovable

As an AI engineer, I am probably not the target user for Lovable. It is mostly aimed at non-technical people, but I do think it needs a few features that would make it more “lovable”:

1. UI drag & drop interface: It placed the output box at the bottom where it shouldn’t be. Asking it to change it via prompt consumes credits. I liked the components, would just want to re-arrange them.

2. Automatic DB schema: Instead of manually adding tables into supabase, I would love that it if it could generate a “reasonable” schema for the project. Funnily enough, I made something that does so here.

3. Initial Options: I would love it if they added a few options at the start — whether I want authentication in my app, want a landing page, and so on. I understand predicting what kind of app a user wants to build is impossible, but just a few checklists could help!

Check out my projects:

Recommendation

Many people are looking for recommendations on what AI apps they should have. There are many AI assisted app builders, I would 100% recommend you have lovable if:

1. You are non-technical and don’t need a sophisticated app!

2. You are technical and need utility apps or UI components.

As a non-technical person who needs a sophisticated app (but can’t hire an engineer) you should consider cursor or claude code. Simply, because I feel they are more engineering tools, while lovable is a no-code utility app builder.

Thank you for reading!

Try Lovable

At FirebirdTech, We believe in transparency and openness; we love to show how we build our projects. Carrying on with that spirit, we have recently launched the AI SQL Trainer in beta. This blog post shows how the backend of the application works.

You can register to use the beta here: https://tally.so/r/n9A2M

Here is a glossary of the AI components in the system:

1. Schema Generator: Takes an initial prompt from the user & creates a schema. Then populates the tables with some data.

2. Question Generator: Generates questions by looking at the schema, topic and difficulty chosen by the user

3. AI competitor: The AI competes with the human in SQL, based on difficulty and schema.

Note: For simplicity's sake we would be working with SQlite/DuckDB for the beta version, but others can be added just the same!

Subscribe now

Schema Generator

In the app before training begins, users can with the help of AI generate a schema. They can generate a schema for almost anything ecommerce, restaurants, telecom & even spaceships!

Code for Schema generator

Like with most of our projects we use DSPy.ai, it helps us optimize the system as we please and it leads to a modular system design that can easily add & subtract components from.

import dspy
# DSPy Signature for the create schema LLM program
class create_schema(dspy.Signature):
    """
    You are a schema generation assistant. Given a natural language description of the data or entities
    the user wants to store, generate a SQL CREATE TABLE schema that defines appropriate tables, columns, 
    and data types. Use sensible names, appropriate data types, and include primary keys. If multiple tables 
    are needed, include foreign key relationships where applicable. Return only the SQL schema.

    Example:
    User Prompt: "I want to store information about books, authors, and publishers. Each book has a title, 
    publication year, genre, and is written by one or more authors. Each author has a name and birth year. 
    Each publisher has a name and address."

    Output: A valid SQL schema containing CREATE TABLE statements to represent this data model.

    Your are using duckDB SQL, which is based on SQLite
    - DO NOT TRY to add foreign_key etc relationships
    
    
    """
    user_prompt = dspy.InputField(desc="The prompt the user has given on what schema they want you to generate")
    schema_sql = dspy.OutputField(desc="The SCHEMA SQL for the requested prompt")

schema_gen = dspy.Predict(create_schema)
schema_prompt = "Generate a schema for an online pet store"

response = schema_gen(user_prompt = schema_prompt)

print(response.schema_sql)

Below is the schema generated, which you can add to any DB engine to execute. Since the system is based on DuckDB, we just connected DuckDB in memory and ran the SQL

# SCHEMA FOR PET STORE

CREATE TABLE Categories (
    category_id INTEGER PRIMARY KEY,
    category_name TEXT NOT NULL
);

CREATE TABLE Products (
    product_id INTEGER PRIMARY KEY,
    product_name TEXT NOT NULL,
    description TEXT,
    price DECIMAL(10, 2) NOT NULL,
    stock_quantity INTEGER NOT NULL,
    category_id INTEGER,
    FOREIGN KEY (category_id) REFERENCES Categories(category_id)
);

CREATE TABLE Customers (
    customer_id INTEGER PRIMARY KEY,
    first_name TEXT NOT NULL,
    last_name TEXT NOT NULL,
    email TEXT NOT NULL UNIQUE,
    phone_number TEXT
);

CREATE TABLE Orders (
    order_id INTEGER PRIMARY KEY,
    customer_id INTEGER,
    order_date DATE NOT NULL,
    total_amount DECIMAL(10, 2) NOT NULL,
    FOREIGN KEY (customer_id) REFERENCES Customers(customer_id)
);

CREATE TABLE OrderItems (
    order_item_id INTEGER PRIMARY KEY,
    order_id INTEGER,
    product_id INTEGER,
    quantity INTEGER NOT NULL,
    price DECIMAL(10, 2) NOT NULL,
    FOREIGN KEY (order_id) REFERENCES Orders(order_id),
    FOREIGN KEY (product_id) REFERENCES Products(product_id)
);

Code for populating tables

Now to populate tables with data, doing so in SQL is actually much harder. A better way to do so, is to create data in Python & then insert those into the DB.

# DSPy signature that generates executable code that when executed will add data
class populate_table(dspy.Signature):
    """
    You are provided with a DuckDB SQL table schema.

    Your task is to write complete Python code that:
    - Uses DuckDB in Python.
    - Generates 250 rows of realistic simulated data based on column types and names.
    - Uses libraries such as `faker`, `random`, or `numpy` for data generation.
    - Creates the table using the exact schema provided.
    - Inserts the generated rows using DuckDB SQL INSERT statements (no DataFrame insertion).
    - Uses parameterized queries to avoid SQL injection and ensure clean formatting.
    - No need to import duckdb or connect it is already connected as conn
    - Do not do conn = duckdb.connect(), it is already connected
    - Take care of the foreign key relations, ensuring you add in good sequence!

    Do not return anything except the Python code.

    One-shot Example:

    Input
    table_schema = '''
    CREATE TABLE users (
        user_id INTEGER,
        full_name VARCHAR,
        email VARCHAR,
        age INTEGER,
        join_date DATE,
        is_active BOOLEAN
    );
    '''

    Output
    python_code = '''
    from faker import Faker
    import random
    from datetime import datetime, timedelta

    # Initialize
    fake = Faker()


    # Insert 250 rows
    insert_query = "INSERT INTO users VALUES (?, ?, ?, ?, ?, ?)"
    for i in range(1, 251):
        full_name = fake.name()
        email = fake.email()
        age = random.randint(18, 70)
        join_date = fake.date_between(start_date='-3y', end_date='today').isoformat()
        is_active = random.choice([True, False])
        conn.execute(insert_query, (i, full_name, email, age, join_date, is_active))
    '''
    """
    table_schema = dspy.InputField(desc="The DuckDB SQL schema for the table")
    python_code = dspy.OutputField(desc="Python code that generates simulated data & adds it via DuckDB SQL")

pop_table_gen = dspy.Predict(populate_table)

# Get the DDL for all tables in the database and print them
tables = [row[0] for row in conn.execute("SHOW TABLES").fetchall()]
schema_result = []
for table in tables:
    ddl = conn.execute(f"DESCRIBE {table}").fetchall()
    schema_result.append((table,ddl))
    print(f"Schema for table '{table}':\n{ddl}\n{'-'*40}")

response = populate_agent(table_schema = str(schema_result))

print(response.python_code)

This is the result of the above code, a Python script that inserts data according to the schema into the tables.

Here is the data tables

Not only do we develop our own AI projects, but we also help clients build with AI the right way. We can help you develop proto-types and production ready systems.

Reach out here: https://tally.so/r/3x9bgo

Question Generator

Now the system needs to generate questions for the user, based on the schema, difficulty & preferred topic.

After experimenting, it is better to have separate LLM programs based on difficulty. Easier to optimize and change on how the system evolves.

class basic_question_gen(dspy.Signature):
    """
    You are part of an AI-powered SQL training system designed to help beginners learn SQL through guided practice.

    Given:
    - A DuckDB database schema (`db_schema`) that includes tables and columns.
    - An optional topic (`topic`) such as SELECT, WHERE, JOIN, GROUP BY, etc.

    Your task:
    - Generate 1 beginner-level SQL question based on the provided schema and topic.
    - If the topic is 'All', select a fundamental concept like:
        - Selecting columns
        - Filtering rows
        - Sorting data
        - Using COUNT or SUM
        - Applying LIMIT

    Output:
    - A clear and simple question related to the schema.
    - A correct SQL solution for that question.
    """
    db_schema = dspy.InputField(desc="The schema of the DuckDB database")
    topic = dspy.InputField(desc="The SQL topic user wants to learn", default="All")
    question = dspy.OutputField(desc="A single basic-level SQL question")
    solution_sql = dspy.OutputField(desc="Correct SQL query that solves the question")

class intermediate_question_gen(dspy.Signature):
    """
    You are part of an AI-powered SQL training system designed to help users advance their SQL skills through practical exercises.

    Given:
    - A DuckDB database schema (`db_schema`) that includes tables and columns.
    - An optional topic (`topic`) such as JOINs, GROUP BY, subqueries, etc.

    Your task:
    - Generate 1 intermediate-level SQL question that applies concepts like:
        - JOINs across tables
        - GROUP BY with aggregate functions
        - Subqueries in SELECT or WHERE
        - Filtering using IN, BETWEEN, LIKE
        - HAVING clause

    Output:
    - A clear intermediate-level question that challenges understanding.
    - A correct SQL solution for that question.
    """
    db_schema = dspy.InputField(desc="The schema of the DuckDB database")
    topic = dspy.InputField(desc="The SQL topic user wants to learn", default="All")
    question = dspy.OutputField(desc="A single intermediate-level SQL question")
    solution_sql = dspy.OutputField(desc="Correct SQL query that solves the question")

class hard_question_gen(dspy.Signature):
    """
    You are part of an AI-powered SQL training system designed to help users master advanced SQL through challenging problems.

    Given:
    - A DuckDB database schema (`db_schema`) that includes tables and columns.
    - An optional topic (`topic`) such as advanced JOINs, window functions, CTEs, etc.

    Your task:
    - Generate 1 advanced SQL question involving:
        - CTEs (WITH clause)
        - Window functions (RANK, ROW_NUMBER, etc.)
        - Correlated subqueries
        - Multi-level aggregation
        - INTERSECT, EXCEPT

    Output:
    - A realistic and challenging SQL question.
    - A valid SQL solution that solves the problem.
    """
    db_schema = dspy.InputField(desc="The schema of the DuckDB database")
    topic = dspy.InputField(desc="The SQL topic user wants to learn", default="All")
    question = dspy.OutputField(desc="A single hard-level SQL question")
    solution_sql = dspy.OutputField(desc="Correct SQL query that solves the question")

Based on user feedback, this change will give us better control over how “difficult” the questions actually are. For example, the current “easy” level might be too simple, or “difficult” might be overly challenging. By adjusting the prompts independently, we can fine-tune the difficulty more effectively.

Check Solution

In this program, we need to repeatedly check whether the SQL is executable (both user-generated and system-generated). Next, we need to ensure that the user’s query and the expected result match — remember, there are many ways to achieve the same result, so the user should not be disqualified just because they used a different syntax.

The implementation for this is relatively simple.

Subscribe now

Generate Explanations

Simple LLM program that generates explanation on why the AI answer is correct & user answer is wrong.

class explanation_gen(dspy.Signature):
    """
    You are part of an AI-powered SQL training system that helps users learn from their mistakes.

    Given:
    - `error_generated`: The error message returned by the SQL engine (DuckDB) after running a query.
    - `faulty_sql`: The original SQL query written by the user that caused the error.
    - `corrected_sql`: A corrected version of the SQL query generated by the AI that fixes the issue.

    Your task:
    - Analyze the error message, the user's faulty SQL, and the corrected SQL.
    - Clearly explain what mistake the user made.
    - Avoid technical jargon and use simple English.
    - Focus on teaching the user so they can avoid this mistake in the future.
    - Use analogies or examples only if it helps clarify the concept.

    Output:
    - A single paragraph explanation written for beginners.
    """
    error_generated = dspy.InputField(desc="The error message returned by DuckDB")
    faulty_sql = dspy.InputField(desc="The incorrect SQL query the user wrote")
    corrected_sql = dspy.InputField(desc="The correct SQL query generated by the AI")
    explanation = dspy.OutputField(desc="A clear and beginner-friendly explanation of the mistake")

These explanations help the user learn. Next is the final & gamified AI vs Human competition.

AI vs Human

This will be a timed match between a human and an AI. To ensure a fair challenge, the AI will use a Text-to-SQL agent with a built-in constraint: difficulty level. This constraint intentionally limits the agent’s accuracy based on the selected difficulty, giving humans a more balanced opportunity to compete. Without such a constraint, high-end LLMs typically perform very well on schemas with 5–6 tables, leaving little room for human advantage.

To make it a playable game, we will initially restrict both the model and its response time.

1. In easy mode, the LLM will be a mid-tier model with access to only table names and column names. It will not include column types or sample data.

2. In intermediate mode, the LLM will still be a mid-tier model but will have access to a few-shot examples and column types, though not sample data from each table.

3. In hard mode, the model will be top-tier and equipped with a full-fledged RAG system that can fetch additional information, including sample data from the tables.

All of these modes will be restricted to respond within 5 seconds, while humans will be allowed a full minute.
The implementation of the Text-to-SQL agent is described below, using three separate DSPy signatures for easy, intermediate, and hard modes.

class text2sql_easy(dspy.Signature):
    """
    Easy mode Text-to-SQL agent.

    Uses a mid-tier model with access to only table and column names (no descriptions, examples, or relationships).
    Designed to challenge the AI with limited schema visibility.

    Instructions:
    You are a helpful SQL assistant. Your task is to convert a natural language question into a valid SQL query.

    You are only given the names of tables and their columns. Do not assume any additional relationships, foreign keys, or descriptions.

    Guidelines:
    - Use only the table and column names exactly as provided in the schema.
    - If the question involves multiple tables, use reasonable assumptions to join them (e.g., on common keys like 'id'), but keep it simple.
    - Do not make up columns or tables.
    - Stick to basic SQL syntax (SELECT, WHERE, GROUP BY, ORDER BY, etc.).
    - Avoid overly complex logic or nested queries unless clearly required.

    Return only the SQL query as your final output.
    """
    
    user_question = dspy.InputField(desc="The user's natural language question about the database")
    table_schema = dspy.InputField(desc="Only table names and column names from the database")
    sql_query = dspy.OutputField(desc="The SQL query corresponding to the question")


class text2sql_intermediate(dspy.Signature):
    """
    Intermediate mode Text-to-SQL agent.

    Uses a mid-tier model with access to only table and column names, but includes a set of few-shot examples to guide SQL generation.

    Instructions:
    You are a SQL assistant that translates natural language questions into SQL queries.

    You are given:
    - A database schema (just table and column names).
    - A set of few-shot examples that map natural language questions to SQL queries.

    Guidelines:
    - Learn from the structure, syntax, and logic of the few-shot examples.
    - Only use the table and column names provided in the schema.
    - Do not invent any tables, columns, or relationships not clearly present.
    - If joining tables is needed, use common-sense assumptions based on column names.
    - Keep SQL queries clean, syntactically correct, and aligned with the style of the examples.

    Your output must be a valid SQL query corresponding to the user’s question.
    """

    user_question = dspy.InputField(desc="The user's natural language question")
    table_schema = dspy.InputField(desc="Table and column names")
    sql_query = dspy.OutputField(desc="Generated SQL query")

class text2sql_hard(dspy.Signature):
    """
    Hard mode Text-to-SQL agent.

    Uses a top-tier model with access to a full RAG (retrieval-augmented generation) system and example-based reasoning.
    The agent is equipped with:
    - Schema documentation
    - Table relationships and join logic
    - Domain-specific metadata
    - A set of high-quality few-shot examples (question-SQL pairs)

    Instructions:
    You are an expert-level SQL assistant working with enterprise-scale databases.

    You are given:
    - A user's natural language question.
    - Retrieved context from schema documentation, data dictionaries, relationships, and metadata.
    - A curated set of few-shot examples to illustrate how natural language maps to SQL.

    Guidelines:
    - Carefully review the RAG context to understand schema relationships and constraints.
    - Learn from the structure, logic, and syntax of the few-shot examples.
    - Accurately determine joins, groupings, aggregations, filters, and subqueries.
    - Use table aliases for clarity and write clean, modular SQL.
    - Reflect business logic or terminology when applicable.

    Your output must be a well-formed, executable SQL query that answers the user's question, grounded in both the retrieved context and prior examples.
    """

    user_question = dspy.InputField(desc="The user's natural language question")
    context = dspy.InputField(desc="Context retrieved from schema documentation, join logic, metadata, etc.")
    few_shot_examples = dspy.InputField(desc="Few-shot examples of natural language questions and their corresponding SQL queries")
    sql_query = dspy.OutputField(desc="Generated SQL query")

We are excited to demo this in the coming weeks to actual users.

Here is the waitlist, we will start sending product invites on a first come first serve basis!

Join waitlist!

Many people begin their journey in data analytics using SQL. However, with invention of ChatGPT many are questioning whether these technical skills are still relevant? AI can quickly generate SQL queries if you give it the right context. Many SaaS applications are using AI as a text to SQL agent; but still SQL is a mandatory requirement for majority of data analytics jobs.

Instead of getting into the replacement debate, FireBird Technologies saw a small opportunity to harness AI to train analyst faster than bootcamps and online courses. You can directly learn using Large Language models.

We have built the beta version of the application and here is a waitlist: https://tally.so/r/n9A2MQ

Overview

A brief overview of how the app functions.

Step 1: You tell the AI a scenario or use case for which it will simulate for you. Like if you want to practice on a typical schema of SaaS companies, you just give it a prompt, and it will generate a schema for you.

You can tell what level of difficulty you need to generate for and also what topic you need to practice.

Step 2: The AI generates questions based on your difficulty and schema chosen

It generates practice sessions for you and gives you explanations on what you got wrong.

Step 3: After your done with the session you can view how you did compared with previous sessions in the dashboard.

Step 4 (Optional): You can even learn by competing against our special text to SQL agent

The agent and you go against time to see which generated the SQL query in less time.

We also develop AI solutions for clients. Have done 15 client engagements with companies' worth $100Mn+, and also with small startups.

Reach out here: https://tally.so/r/3x9bgo

We are excited to launch this AI SQL tutor bot. Please follow FireBird Technologies to stay updated. Here are our social media links:

1. Substack

2. Linkedin

Thank you, for reading!

After working on dozens of projects, from early prototypes to full-scale generative AI deployments we at Firebird have seen what works and what doesn’t.

If you’re exploring GenAI for your product or business, this guide will help you cut through the hype.

There’s a lot of pressure right now. Companies feel the need to adopt AI fast, fearing they’ll be left behind. But moving too quickly, or using GenAI just for the sake of it, often leads to wasted time and money.

It’s great to stay ahead of the curve but the generative AI space is also full of overpromises, half-baked solutions, and use cases where GenAI simply doesn’t fit.

Before committing to a adding a Large Language model, run your idea through this evaluation checklist. It will help you avoid bad use cases and build more responsible, effective applications.

Checklist question # 1

Does a deterministic solution already exist?

A simple yet often neglected question. Large Language Models are ultimately predicting the next token based on a learned probability distribution. If you ask an LLM what the weather is like right now, you will see it will give a different response.

Ideally, don’t use an LLM for things that have a clear, straightforward answer. If you need weather data, for example, it’s better to use a trusted API or just check outside yourself.

Building on that idea, here are some examples where clear rule-based solutions already exist, but people still use LLMs even though they are not really needed.

Calculations
Using an LLM for arithmetic is unreliable.

Data Mapping
If you have a known list of key and value pairs, like names and salaries, a deterministic lookup function is the better choice. An LLM adds unnecessary complexity and risk of incorrect mapping.

Validating Information
LLMs cannot reliably validate phone numbers, email addresses, physical locations, or business registrations. They are also not dependable for verifying historical facts unless connected to a web search tool, and even then, they can still make things up.

Cleaning and Parsing Information
When you need to clean a string or fix formatting errors, use tools like regular expressions. If the issue follows a predictable pattern, a defined set of rules will work better than asking an LLM to guess.

Regressing or Predicting Numbers
For predicting numeric values or trends, a simple linear regression model is often more accurate and transparent than using an LLM.

Note: Some readers might be confused as many of these things are done with high accuracy if you ask chat interface like ChatGPT. The answer is that the chatbot uses deterministic tools to answer those queries and later asks the LLM to relay that information. ChatGPT calling a calculator to answer calculations is different than asking the LLM to do the calculation.

The difference is subtle when developing your own solution by calling the API you need to make sure the request is relayed to a deterministic function not the LLM.

Looking for experts to help identify and implement the correct solution for you?

Reach out here: https://tally.so/r/3x9bgo

Checklist question # 2

What is the cost? Is this economically viable? Are cheaper solutions available?

After clearing question one, you have found no deterministic solution to your problem. The next important question to ask are Large Language models economical for this problem.

One example of a non-deterministic problem for which LLM might not be economically feasible are classification problems. Many people are using LLM for text classification. In certain cases that makes sense but in many it absolutely does not. An obvious way to evaluate is looking at how much additional $ are you paying for an improvement in classification accuracy.

Most traditional classifiers might incur some compute cost but let’s assume that is 0.

After figuring out cost per improvement you’re paying the next step is evaluating what benefit you are getting per improvement of accuracy.

If the $ benefit per improvement due to LLM is greater than $ cost per improvement in LLM, you can use an LLM for that task, if not it is economically unviable.

Note: You can replace accuracy with any metric that captures the performance of the task you are doing. Also calculating $ benefit might be tough, so it is not uncommon to use some estimate. You ideally use a number that helps you stay inside your budget. We at Firebird are specialists in figuring this out for you: Reach out for a consultation!

Here are some other examples where LLMs are being used but it might be wise to figure out if they are cost effective:

1. OCR and parsing images: If you have black & white text on an image. Traditional OCR tools can be much more precise & cost effective. As vision capabilities of LLM are not immune to hallucination.

2. Recommendation Algorithms: LLMs can be used to recommend items if you give text descriptions, but whether the benefit (if any) is worth the additional cost needs to be calculated

3. Sentiment Analysis: It is likely that for most sentiment analysis use cases an LLM will be more ‘accurate’ than other NLP techniques but is the additional accuracy worth it? Often neglected as the benefit might be small, but the cost could be high.

4. Categorization: Assigning tags and categories based on text descriptions. Common nowadays but if you need to do this in bulk, it is advisable to use a mixed (where an LLM is only used on hard examples) or simpler solution.

Checklist question # 3

What is the risk & damage to my brand/business in the case of hallucination?

The last question is a risk assessment question, similar to the financial concept of value at risk. In simple terms, when making an investment it is advisable to look at the damage or loss in the worst case scenario.

Similarly, we should assume that whatever application we are building will malfunction due to the LLM hallucinating. In the absolute worst-case scenario what is the potential damage to the company brand.

In certain cases, your company and brand might be liable for damages if their application malfunctions. You should definitely come up with a framework to assess damages.

Here are some obvious ones where you should be careful:

1. Data Accuracy: If your business relies on providing factually correct information, and even a small error could trigger damages. You should definitely be careful with using LLMs. This is common in the finance industry.

2. Legal: If you are a lawyer and you rely heavily on AI for preparing legal documents, you might be held liable for hallucinations.

3. Content generation: Character.AI was sued for the suicide of a minor, because their AI allows users to generate NSFW content. That may be damaging to children. If you work with adult/sensitive content you must be ensure AI does not produce harmful material.

4. Hiring HR: Many countries have laws against discrimination in employment; AI is not fair and can be discriminatory. Which could result in legal penalties.

The important thing to remember is that you should assume that AI will hallucinate and cause your product to malfunction. Even after adding guardrails, you cannot be completely sure that your application will not fault. If the risk to high, you should avoid or limit AI use.

Hopefully you found the information in the blog post helpful. Please follow us on Medium, Substack & Linkedin to stay up to date on AI.

Here are some important updates for the autoanalyst.ai.

We have added new capabilities under three categories:

1. Data Manipulation: Now there are more options for data cleaning and pre-processing. Here are some of the agents added:

• Polars Agent: Polars is a powerful open-source library which is faster than pandas. Allows for quick data manipulation especially on large datasets

• Numpy Agent: Numpy is used for fast manipulation of matrices and vectors. A key component in many data science applications such as deep learning and even visualization.

2. Data Modelling: Modelling is a key step in data science. Previously the system only leveraged sci-kit learn for machine learning and statsmodel for statistical analysis. Now it has more capabilities available:

• XGBoost Agent: A advanced Machine learning algorithm used for predictions on tabular data. Often used for applications where high predictive accuracy is desired

• PyMC Agent: Bayesian modelling agent, which helps model complex probabilistic behavior, and find estimates for Bayesian inference.

• LightGBM Agent: A popular alternative to XGBoost especially as it uses less compute, now available.

• Scipy Agent: Can run probabilistic simulations especially useful for financial modelling

3. Data Visualizations: The system is pre-programmed with a advanced plotting agent which uses plotly. Now it has more visualization capabilities!

• Matplotlib Agent: A popular ploting library for static plots, almost universally used.

• Seaborn Agent: A wrapper on matplotlib, which offers a more modern look to matplotlib charts.

All of these capabilities are now live at autoanalyst.ai.

Firebird Technologies is a AI consultancy and SAAS developer. If you’re looking to test, develop and productionize AI capabilities, you can reach out here: https://tally.so/r/3x9bgo

You can use these new agent templates with existing planner and deep analysis capabilities.

Want a custom development of the Auto-Analyst:

https://www.autoanalyst.ai/contact

The following is the story behind why we are adding this feature. It all began by a client engagement for firebird technologies.

Meet Sarah, a customer insights manager at a fast-growing SaaS company. Every 2 weeks or so, she’s flooded with questions like: Why is churn changing? Why are customers leaving/coming back in larger/lower numbers?

Watch the video version of this post, made using blog2video.app

The data is all there — but churn is an evolving issue. Products and markets are not static, every time Sarah needed to do a deep dive on the same dataset source but the conclusions she draws could be different.

She & by extension our client needed a way to automate this analysis, but instead of a fixed workflow they needed something that is able dynamically change the analysis based on the latest data. Come up a evidence backed conclusion every time.

That’s why we built Deep Analysis feature in Auto-Analyst. With a single query, Sarah now gets structured deep dives — correlation patterns, anomaly flags, segment-level breakdowns.

Try the Auto Analyst

Unlike fixed workflows, it is a dynamic analytics system that does the following:

1. Indepth Query Rewrite: The system comes up with 5 adjacent research questions after looking at the higher picture of the data & relates it to the original query.

2. Advanced Planning: The Auto-Analyst already has a well-reasoned planning system, but deep analysis’s planner plans for 5 queries simultaneously, ensure you get coherent, fast & reliable results.

3. Concurrent Execution: All 4 agents in the system work on all 5 questions together, ensuring speed.

4. Analytical Synthesis: Synthesizes the code & summary analytics for all agents & all questions into a coherent analytics report. Like this: https://firebird-technologies.github.io

The system works independently, and you can ask other questions while it prepares you your reports.

Technical Breakdown

This section covers how the system operates and how it is different from a traditional query to the system.

Traditional Query

Query -> Planner -> Agents -> Result.

Deep Analysis Query

Query -> 5 Indepth Research questions -> Planner -> Agents -> Synthesis -> Conclusion -> Result (shown as a report)

Deep Analysis overcomes some of the limitations in a traditional query.

1. It clears up confusion in the user’s question and breaks it down into 5 helpful sub-queries. These are designed to better answer the original question.

2. Once the agents finish running their parts, Deep Analysis puts everything together — the code, the outputs, and the text. It fixes any code issues, fills in missing info, and understands what each agent found. This step is called synthesis, as it synthesizes all information

3. In the end, it shares a conclusion that includes a clear conclusion, a recommendation, and suggested next steps.

Want a custom AI report generator? Specifically designed with your business in mind. Or a custom integration tailored to your analytical needs

Contact us: https://autoanalyst.ai/contact

Use cases

Here are some use cases where we or our clients have used Deep Analysis.

The names and other information have been changed for privacy

1. Academic Research — Finding What Really Matters
Dr. Meera, a public health researcher, was studying the link between screen time and mental health in teenagers. She had a large dataset with dozens of variables like age, gender, social media usage, sleep hours, and more. But finding which factors truly mattered was hard.

With Deep Analysis, she asked one question: “What influences mental health scores the most?”

The system broke it down, ran multiple focused queries, tested relationships, and synthesized everything into a clear answer. She didn’t just get correlations, she got explanations, recommendations for further study, and confidence in her results.

See sample report (made with synthetic data for data privacy)

Link: Mental Health Report Sample

2. Product Analysis — Understanding What’s Working
Jake, a product manager at a B2B SaaS company, wanted to understand why usage of a new feature dropped after launch. Traditional dashboards showed the numbers but not the reasons.

He ran a Deep Analysis with the question: “Why are users not using Feature X after launch?”

The tool explored patterns across user segments, time, plan types, and onboarding flow. It spotted a drop-off after a UI change and found that power users in the enterprise plan were least engaged.

Within minutes, Jake had a clear report with causes, suggested fixes, and a list of user segments to focus on.

See sample report (made with synthetic data because client data is proprietary, but analysis is same)

Link: Product Analytics Sample

3. User Analysis — Finding Drop-off Points
Nina, a growth analyst at a consumer app, noticed a dip in weekly active users. She wasn’t sure if it was a seasonal change or a deeper problem.

Using Deep Analysis, she asked: “What’s driving the drop in weekly active users?”
The system ran comparisons across time, cohorts, features, and user behavior. It found that new users who signed up via a recent ad campaign were dropping off during onboarding due to slow load times on Android devices.

Instead of guessing, Nina now had a clear explanation and a fix that helped turn numbers around the next week.

See sample report (made with synthetic data because client data is proprietary, but analysis is same)

Link: https://arslans1997.github.io/drop-off.html

Next Steps

This is not the first version of the feature, we will continuously add improvements. Here are some in the pipeline:

1. Multi-data set deep analysis

2. User preference adjustment, we would like the users to be able to adjust the feature to their liking

Thank you for reading!

Wanna start deep analyzing?

https://autoanalyst.ai