DEV Community: Suresh

I Built a Real-Time Financial Dashboard That Talks Directly to Tally Prime's XML API

Suresh — Wed, 03 Jun 2026 12:01:37 +0000

Every accountant I spoke to had the same complaint.

Open Tally Prime → export data → wait → open Excel → format it → wait some more.

Repeat this every single day for ledgers, invoices, balance sheets.

It was slow, manual, and error-prone. One wrong cell in Excel and the numbers don't match. One missed export and the report is already stale.

So I built TallySync - a real-time financial dashboard that talks directly to Tally Prime via its XML API. Create ledgers, push invoices, pull data, view analytics - all from a clean web UI, without touching Tally's menus at all.

🎥 Live Demo: sureshcodes.vercel.app/tallysync

📂 Source Code: github.com/Suresh4405/TallySync-Portal

What It Does

Create ledgers (with GST, PAN, address, opening balance) and push them straight into Tally
Create sales invoices and sync them as vouchers in Tally
Pull ledgers from an existing Tally company into the dashboard database
View analytics — revenue charts, sync status breakdowns, ledger summaries
Admin panel to manage users and monitor sync logs
JWT-based auth with protected routes

The Tech Stack

Frontend: React + Vite, Material UI, Recharts, Axios

Backend: Node.js + Express, Sequelize ORM, MySQL

Tally Integration: Tally XML API (ODBC port 9000)

How It Works

Step 1: Tally's XML API

Tally exposes a local HTTP server on port 9000 when ODBC is enabled. You can send XML envelopes to it and it either exports data or imports it directly into the active company.

To enable it: open Tally → F11 → F1 → Enable ODBC Server

Here's how the backend talks to Tally:

// services/TallyService.js
async sendRequestToTally(xmlData) {
  const response = await axios.post(this.tallyHost, xmlData, {
    headers: {
      'Content-Type': 'application/xml',
      'Accept': 'application/xml'
    },
    timeout: 30000
  });
  return response.data;
}

If ECONNREFUSED comes back, the app catches it and gives a clear message instead of a cryptic error.

Step 2: Creating a Ledger in Tally

When you submit a ledger form in the UI, the backend saves it to MySQL first, then fires an XML import request to Tally:

// services/TallyService.js
async createLedgerInTally(ledgerData, userId) {
  const isConnected = await this.testTallyConnection();
  if (!isConnected) {
    throw new Error('Cannot connect to Tally. Please check Tally is running.');
  }

  const xml = `<?xml version="1.0" encoding="UTF-8"?>
<ENVELOPE>
  <HEADER>
    <TALLYREQUEST>Import Data</TALLYREQUEST>
  </HEADER>
  <BODY>
    <IMPORTDATA>
      <REQUESTDESC>
        <REPORTNAME>All Masters</REPORTNAME>
      </REQUESTDESC>
      <REQUESTDATA>
        <TALLYMESSAGE xmlns:UDF="TallyUDF">
          <LEDGER NAME="${ledgerData.ledger_name}" Action="Create">
            <PARENT>${ledgerData.parent_group || 'Sundry Debtors'}</PARENT>
            <OPENINGBALANCE>${ledgerData.opening_balance || 0}</OPENINGBALANCE>
            <GSTREGISTRATIONTYPE>Regular</GSTREGISTRATIONTYPE>
            <PARTYGSTIN>${ledgerData.gst_number || ''}</PARTYGSTIN>
          </LEDGER>
        </TALLYMESSAGE>
      </REQUESTDATA>
    </IMPORTDATA>
  </BODY>
</ENVELOPE>`;

  const response = await this.sendRequestToTally(xml);
  // parse response, extract GUID, update DB record
}

If Tally accepts it, the tally_guid is extracted from the response and saved back to the DB so the record is fully traceable.

Step 3: Pulling Ledgers Back from Tally

The sync is bidirectional. The app can also fetch all ledgers from Tally and upsert them into MySQL:

async syncLedgersToDatabase(userId) {
  const tallyLedgers = await this.getLedgersFromTally();

  for (const tallyLedger of tallyLedgers) {
    const [ledger, created] = await TallyLedger.findOrCreate({
      where: { ledger_name: tallyLedger.name },
      defaults: {
        ledger_name: tallyLedger.name,
        parent_group: tallyLedger.parent,
        opening_balance: parseFloat(tallyLedger.opening_balance) || 0,
        closing_balance: parseFloat(tallyLedger.closing_balance) || 0,
        tally_guid: tallyLedger.guid,
        synced_at: new Date()
      }
    });

    if (!created) {
      await ledger.update({ closing_balance: ..., synced_at: new Date() });
    }
  }
}

Step 4: The Dashboard & Analytics

The dashboard shows:

Total ledgers, invoices, synced count, failed syncs
Revenue trend (bar/line/area chart via Recharts)
Sync status pie chart (pending / success / failed)
Recent sync activity log

The analytics page lets you filter by date range and toggle between chart types.

The Database Schema

Three core tables:

tally_ledgers — stores ledger data with tally_guid, synced_at, GST, PAN, address, balances

tally_invoices — stores invoice/voucher data with sync_status enum (pending / success / failed)

sync_logs — audit trail of every push/pull operation with timestamps and error messages

Sequelize handles migrations with sync({ alter: false }) in production so the schema doesn't get nuked on redeploy.

What Broke First

XML parsing. Tally's response XML is deeply nested and the tag names change depending on the operation. I had to write a dedicated parser that extracts the GUID and checks for error strings inside the response body — because Tally returns HTTP 200 even when the import fails. The error is buried in the XML.

Connection refused with no context. The first time Tally wasn't running, the frontend just showed a generic 500. I added explicit ECONNREFUSED handling in the service layer so users get a helpful checklist instead.

Why I Stored Data in MySQL Too

I could have just been a passthrough — send to Tally and forget. But having a local copy means:

You can query, filter, and show analytics without hitting Tally every time
You have a sync log to audit what succeeded and what failed
If Tally is offline, users can still view existing records

Setup

# Server
cd server
cp .env.example .env  # set DB_HOST, TALLY_HOST, JWT_SECRET
npm install
node indexserver.js

# Client
cd client
cp .env.example .env  # set VITE_API_URL
npm install
npm run dev

Make sure Tally is open with ODBC enabled on port 9000. The app checks the connection before every push operation.

🚀 Live Demo

https://sureshcodes.vercel.app/tallysync

📂 Source Code

github.com/Suresh4405/TallySync-Portal

👨‍💻 Portfolio

sureshcodes.vercel.app

Drop a 🧡 if this was useful — especially if you've ever fought with Tally's XML API.

I built a bulk email tool in one evening — no database, no .env, credentials never stored

Suresh — Wed, 03 Jun 2026 10:15:42 +0000

Every week I had to send 100+ personalized emails.

Open Excel → copy name → paste → change email → repeat 100 times.

It was taking nearly 3 hours every week.

So instead of doing it manually again, I spent one evening building a tool that does the same job in about 2 minutes.

What it does

Upload Excel file → Parse data → Detect columns → Write template with {{variables}} → Preview emails → Send all via Gmail

✅ No database

✅ No .env

✅ No stored credentials

✅ No authentication setup

✅ Works with Gmail App Passwords

🔗 Live Demo: https://bulk-mail-sender-lilac.vercel.app/

📂 Source Code: https://github.com/Suresh4405/BulkMail-Sender

👨‍💻 Portfolio: https://sureshcodes.vercel.app/

Why I Built It

Most bulk email tools either:

Charge monthly fees
Require complicated setup
Store your credentials somewhere

I wanted something simpler.

A tool where credentials exist only during the current request.

Once the emails are sent, everything disappears from memory.

That became the core design principle behind the project:

If there is no stored data, there is nothing to leak.

How It Works

Step 1: Login with Email & App Password

The user enters a Gmail address and App Password.

The credentials are verified instantly before sending any emails.

Code – app/api/testCredentials/route.ts

import { NextRequest, NextResponse } from 'next/server';
import nodemailer from 'nodemailer';

export async function POST(request: NextRequest) {
  try {
    const { email, password } = await request.json();

    const transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        user: email,
        pass: password,
      },
    });

    await transporter.verify();

    return NextResponse.json({ success: true });
  } catch {
    return NextResponse.json(
      { success: false },
      { status: 401 }
    );
  }
}

Step 2: Import Your Excel File

Upload any Excel spreadsheet.

The application automatically:

Reads the file
Detects columns
Generates variables
Shows a preview before sending

Example data:

Name	Company	Email
John	Tesla	john@example.com
Sarah	Netflix	sarah@example.com

The detected columns become variables like:

{{Name}}
{{Company}}
{{Email}}

Code – app/api/readExcel/route.ts

import { NextRequest, NextResponse } from 'next/server';
import * as XLSX from 'xlsx';

export async function POST(request: NextRequest) {
  try {
    const formData = await request.formData();
    const file = formData.get('excel') as File;

    const bytes = await file.arrayBuffer();
    const buffer = Buffer.from(bytes);

    const workbook = XLSX.read(buffer, {
      type: 'buffer',
    });

    const sheet =
      workbook.Sheets[workbook.SheetNames[0]];

    const rows =
      XLSX.utils.sheet_to_json(sheet);

    const columns =
      Object.keys(rows[0] || {});

    return NextResponse.json({
      columns,
      allData: rows,
      preview: rows.slice(0, 5),
    });
  } catch {
    return NextResponse.json({
      columns: [],
      allData: [],
      preview: [],
    });
  }
}

Step 3: Write Email & Send (Live Preview)

Write your email once using variables.

Example:

Hi {{Name}},

I came across {{Company}} and wanted to connect.

Best,
Suresh

The application automatically personalizes every email.

Frontend – app/page.tsx

const insertVariable = (variable: string) => {
  const insertion = `{{${variable}}}`;

  switch (activeField) {
    case 'to':
      setTo(
        prev =>
          prev +
          (prev ? ' ' : '') +
          insertion
      );
      break;

    case 'body':
      const start =
        textarea.selectionStart;

      const end =
        textarea.selectionEnd;

      const newText =
        body.substring(0, start) +
        insertion +
        body.substring(end);

      setBody(newText);
      break;
  }
};

Backend – app/api/sendEmails/route.ts

const transporter = nodemailer.createTransport({
  service: 'gmail',
  auth: {
    user: senderEmail,
    pass: senderPassword,
  },
});

for (const row of rows) {
  await transporter.sendMail({
    to: replaceVariables(toTemplate, row),
    subject: replaceVariables(
      subjectTemplate,
      row
    ),
    html: markdownToHtml(
      bodyTemplate,
      row
    ),
  });

  await new Promise(resolve =>
    setTimeout(resolve, 1000)
  );
}

Helper Functions

function replaceVariables(
  template: string,
  row: any
) {
  return template.replace(
    /{{(.*?)}}/g,
    (_, key) => row[key.trim()] || ''
  );
}

function markdownToHtml(
  markdown: string,
  row: any
) {
  const withVars =
    replaceVariables(markdown, row);

  return withVars.replace(
    /\*\*(.*?)\*\*/g,
    '<strong>$1</strong>'
  );
}

The Privacy Design

Most bulk email tools store your Gmail credentials somewhere.

This one doesn't.

The flow is simple:

Enter credentials
       ↓
Verify credentials
       ↓
Send emails
       ↓
Request ends
       ↓
Memory cleared

No database.

No Redis.

No log file.

No .env.

No stored credentials.

Tradeoff?

You enter credentials each session.

Benefit?

Nothing sensitive remains after the request completes.

What Broke The First Time

The first version worked perfectly.

Until I tried sending 100 emails.

I fired requests as fast as Node.js could loop.

By email #47 Gmail responded with:

User rate limit exceeded

The remaining emails never sent.

That forced me to learn Gmail's sending limits and add throttling.

Rate Limiting (The 1-Second Delay)

The fix was surprisingly simple:

await new Promise(resolve =>
  setTimeout(resolve, 1000)
);

One second per email.

100 emails = roughly 100 seconds.

A little slower.

A lot more reliable.

Lessons Learned

Building the tool took a few hours.

Making it reliable took longer.

A few things I learned:

Gmail rate limits matter
Simplicity is often a security feature
Excel is still the easiest format for non-technical users
Small tools solving real problems are often the most useful projects

Sometimes the best side projects aren't startups.

They're solutions to annoyances you face every week.

Tech Stack

Next.js 15
TypeScript
Nodemailer
XLSX
Tailwind CSS
Vercel

Future Improvements

A few features I'm considering:

Scheduled campaigns
Retry queue
CSV support
Email analytics
Progress tracking
Background processing

Try It Yourself

🚀 Live Demo

https://bulk-mail-sender-lilac.vercel.app/

📂 Source Code

https://github.com/Suresh4405/BulkMail-Sender

👨‍💻 Portfolio

https://sureshcodes.vercel.app/

From 3 hours of copy-pasting to 2 minutes of automation.

Built in one evening with Next.js, Nodemailer, and zero stored credentials.

If you've ever had to send hundreds of personalized emails manually, leave a 🧡 and tell me how you're solving it.