Forem: muhammad naveed

I Built a Julius AI Alternative in Next.js — Here's What I Learned

muhammad naveed — Sat, 16 May 2026 11:54:48 +0000

Tags: nextjs ai buildinpublic startup

Six weeks ago I started building WhyAnalyst — an AI-powered data analysis tool where you upload a CSV or Excel file and ask questions in plain English. Think Julius AI, but free to start.

This post is about what actually happened when I built it: the technical decisions, the mistakes, the costs, and the things nobody tells you when you're building an AI SaaS as a solo developer.

The stack

Before I get into the lessons, here's what I built it with:

Frontend:  Next.js 14 (App Router)
Auth:      Firebase Authentication
Database:  Firestore
AI:        Google Gemini Flash (switched from GPT-4 — more on this)
Hosting:   Vercel (frontend) + Render (backend API)
Payments:  LemonSqueezy (coming soon)

Total monthly cost at zero users: ~$0. At 100 active free users: still roughly $0. The free tiers on all of these are genuinely generous.

The AI cost problem — and how I solved it

This is the thing that almost killed the project before it started.

My first implementation was naive: user uploads CSV → I send the entire file to the AI → AI answers the question. For a 500-row CSV with 10 columns, that's easily 5,000–10,000 tokens per query. At GPT-4 pricing, that adds up terrifyingly fast.

// ❌ What I started with — extremely expensive
const response = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{
    role: "user",
    content: `Here is my data: ${JSON.stringify(entireCSV)}\n\nQuestion: ${userQuestion}`
  }]
})

The fix was to stop sending raw data to the AI entirely. Instead, I send metadata about the data and let the AI generate analysis code, which runs locally:

// ✅ What I do now — much cheaper
const dataContext = {
  columns: csvData.columns,           // column names only
  sample: csvData.rows.slice(0, 5),   // first 5 rows only
  rowCount: csvData.rows.length,      // total row count
  dtypes: inferColumnTypes(csvData),  // inferred data types
}

const response = await gemini.generateContent(`
  You are a data analyst. Given this dataset context:
  ${JSON.stringify(dataContext)}

  Generate JavaScript code to answer this question: "${userQuestion}"
  The full data array is available as the variable 'data'.
  Return only valid JSON: { code: string, chartType: string, title: string }
`)

// Execute the generated code against the actual data client-side
const result = new Function('data', generatedCode)(csvData.rows)

I also switched from GPT-4 to Gemini 1.5 Flash, which has a generous free tier and is fast enough for this use case. For most CSV analysis questions, the output quality is indistinguishable.

Cost reduction: ~85%

Firebase Auth + Firestore for usage limits

One of the most important things for a freemium AI tool is tracking usage per user so you can enforce limits. Here's the pattern I use:

// Called on every analysis attempt
async function checkAndIncrementUsage(userId) {
  const userRef = doc(db, 'users', userId)

  return await runTransaction(db, async (transaction) => {
    const userDoc = await transaction.get(userRef)
    const { queriesUsed, queriesLimit, plan } = userDoc.data()

    if (queriesUsed >= queriesLimit) {
      throw new Error('LIMIT_REACHED')
    }

    transaction.update(userRef, {
      queriesUsed: increment(1),
      lastActiveAt: serverTimestamp()
    })

    return { allowed: true, remaining: queriesLimit - queriesUsed - 1 }
  })
}

I use a Firestore transaction here (not just an update) to avoid race conditions if someone somehow fires two requests simultaneously.

On signup, I create the user document with defaults:

// Firebase Auth onAuthStateChanged → create user doc if new
async function initializeNewUser(firebaseUser) {
  const userRef = doc(db, 'users', firebaseUser.uid)
  const existing = await getDoc(userRef)

  if (!existing.exists()) {
    await setDoc(userRef, {
      email: firebaseUser.email,
      plan: 'free',
      queriesUsed: 0,
      queriesLimit: 10,
      createdAt: serverTimestamp(),
      onboardingComplete: false
    })
  }
}

Parsing CSV and Excel on the client

One mistake I made early: sending files to the server for parsing. It's slower, uses server resources, and creates privacy concerns for users with sensitive data. Everything now parses in the browser:

import Papa from 'papaparse'
import * as XLSX from 'xlsx'

async function parseFile(file) {
  const ext = file.name.split('.').pop().toLowerCase()

  if (ext === 'csv') {
    return new Promise((resolve) => {
      Papa.parse(file, {
        header: true,
        skipEmptyLines: true,
        complete: (results) => resolve({
          columns: results.meta.fields,
          rows: results.data
        })
      })
    })
  }

  if (ext === 'xlsx' || ext === 'xls') {
    const buffer = await file.arrayBuffer()
    const workbook = XLSX.read(buffer)
    const sheet = workbook.Sheets[workbook.SheetNames[0]]
    const rows = XLSX.utils.sheet_to_json(sheet)
    return {
      columns: Object.keys(rows[0] || {}),
      rows
    }
  }
}

This runs instantly even for large files, and the data never leaves the user's browser until they explicitly ask a question.

The biggest non-technical mistake I made

I built too many features before talking to any users.

Look at my sidebar right now: Workspace, Files, Databases, History, Mission Log, Custom Agents, Notebook Templates, Connect Data. Most of these are either empty or barely functional.

I was building what I imagined users wanted. The reality: every single person who tried the tool just wanted to upload a file and ask a question. That's it. The feature they asked for most often wasn't in any of my sidebar items — it was "can I download the chart as a PNG?"

Lesson: Build the smallest possible thing. Ship it. Watch what real people actually do. Then build the next thing.

What's actually working for user acquisition

Since I have zero marketing budget, I've been trying different channels:

Reddit posts in r/datascience and r/excel with a demo GIF → best ROI so far
Building in public on Twitter → slow but compounds over time
This kind of post → you're reading it, so it works at least a little
SEO pages targeting "julius ai alternative", "chatgpt data analysis alternative" → still building, too early to tell

What hasn't worked: posting in Facebook groups, cold DMs, ProductHunt (haven't launched yet, but prep is underway).

Current status and what's next

WhyAnalyst is live at whyanalyst.vercel.app. Free tier gives you 10 analyses per month, no credit card required.

Things I'm working on next:

Chart export (PNG/PDF) — most requested feature
Persistent file storage so you don't have to re-upload every session
A Chrome Extension that reads Google Sheets data directly
Payments via LemonSqueezy for the Pro tier ($9/month)

Would I do it again?

Yes, but I'd do two things differently:

Talk to 10 potential users before writing a single line of code. I would have built a much simpler first version.
Switch to Gemini Flash from day one. I wasted time and money on GPT-4 for a use case where Flash is genuinely good enough.

If you're building something similar — an AI wrapper, a SaaS tool, anything in this space — feel free to ask questions in the comments. Happy to share more about the technical side or the business side.

And if you want to try the tool (or roast the UI), here it is. Feedback welcome.

Building WhyAnalyst in public. Follow along if you're into that sort of thing.

WhyAnalyst: Why Every Data-Driven Decision Needs Better Analysis

muhammad naveed — Wed, 13 May 2026 07:38:50 +0000

Here is the link of app : https://whyanalyst-438909629186.asia-south1.run.app/
In today’s world, data is everywhere — but insight is rare.

That’s exactly why I started exploring the idea of WhyAnalyst: a mindset (and potential framework) focused on asking not just what the data says, but why it says it and what to do next.

📊 The Problem with Modern Data Work

Most teams today have access to dashboards, BI tools, and analytics platforms. But despite that, a common issue remains:

Reports are generated, but not deeply understood
Metrics are tracked, but not questioned
Decisions are made on surface-level interpretation

In short: we have more data, but not always better analysis.

🧠 What “WhyAnalyst” Means

WhyAnalyst is about shifting from passive reporting to active reasoning.

Instead of stopping at:

“Sales dropped 12%”

We go further:

Why did sales drop?
Was it traffic, conversion, pricing, or seasonality?
Which segment was most affected?
What changed before the drop occurred?

It’s about building a habit of analytical curiosity.

🔍 Core Principles of WhyAnalyst

Always Ask “Why?”

Never accept surface-level metrics without investigation.

Break Down Every Metric

Every number is a combination of smaller drivers.

Look for Causality, Not Just Correlation

Not everything that moves together is connected.

Focus on Actionable Insight

Analysis is only useful if it leads to decisions.

⚙️ Where This Applies

WhyAnalyst thinking is useful in:

Data analytics & business intelligence
Product analytics
Marketing performance analysis
AI model evaluation
Financial decision-making

Anywhere data is used — this mindset improves outcomes.

🚀 Why It Matters

As AI and automation grow, raw analysis is becoming cheaper.

What remains valuable is:

Critical thinking
Interpretation
Decision-making based on uncertainty

That’s where human analysts still win — and where WhyAnalyst fits in.

🤝 Final Thought

WhyAnalyst is not a tool — it’s a habit.

A habit of refusing to stop at “what happened” and always pushing toward “why it happened” and “what should happen next.”

My Journey to Becoming a Full-Stack Developer

muhammad naveed — Tue, 18 Mar 2025 06:24:50 +0000

Introduction

Hello, Dev.to community! My name is Muhammad Naveed, and I am on an exciting journey to becoming a full-stack developer. I started my journey with basic web development and am now diving deep into frontend and backend technologies. In this post, I’ll share my experience, challenges, and the roadmap that helped me get started.

Getting Started with Web Development

Like many beginners, I started with the fundamentals:

HTML & CSS: Learning the structure and styling of web pages.

Bootstrap: To quickly create responsive designs.

JavaScript: To make my websites interactive.

It took me about a month to feel comfortable with these technologies, and I built a few basic projects like landing pages and portfolio websites.

Diving into JavaScript and DOM Manipulation

After mastering the basics, I focused on JavaScript:

DOM Manipulation: Understanding how to update the UI dynamically.

Functions & Callbacks: Learning how to structure JavaScript code.

APIs: Exploring how to fetch data using the Unsplash API.

One of the most important things I learned was how JavaScript handles asynchronous operations, which prepared me for working with APIs and backend technologies.

Moving Towards Full-Stack Development

Once I gained confidence in frontend development, I started learning backend technologies:

Node.js & Express.js: To build server-side applications.

MongoDB: To store and manage data.

REST APIs: Creating and consuming APIs.

I also started learning about authentication, authorization, and deploying applications on cloud platforms.

Challenges I Faced

Like any learning journey, I faced challenges such as:

Understanding complex JavaScript concepts like closures and promises.

Debugging errors and learning how to use browser dev tools effectively.

Managing time effectively while learning full-time.

The key to overcoming these challenges was consistency, building projects, and engaging with the developer community.

My Next Steps

As I continue my learning, I plan to:

Work on more full-stack projects.

Explore React.js and Angular for frontend frameworks.

Improve my problem-solving skills by practicing algorithms and data structures.

Conclusion

The journey to becoming a full-stack developer is challenging but rewarding. If you're starting, my advice is: stay consistent, build projects, and never stop learning!

What’s your full-stack development journey like? Let’s discuss in the comments!