Compliance Management India with DoAide Comply

#react #fastapi #postgres #compliance

The Compliance Calendar: A Single Source of Truth for Regulatory Tracking

Problem

Indian small‑and‑medium businesses, chartered accountants, and compliance officers face a fragmented landscape of deadlines. GST returns, ROC filings, FSSAI labelling, and labour‑law checklists all have distinct due dates, forms, and filing portals. A missed GST‑GSTR‑9 filing can trigger a ₹50,000 penalty, while an overdue ROC return can result in a ₹5,000 fine and a public notice. Traditional spreadsheets or disparate task lists make it easy to lose track of these obligations.

The core pain point is regulatory tracking: keeping a live, accurate, and searchable list of obligations across multiple regulatory domains. Existing tools either focus on a single domain (e.g., GST) or require manual export/import between systems. For compliance management in India, a unified calendar that aggregates all deadlines is essential. This is where compliance management india pays off in practice.

Architecture Overview

DoAide Comply’s compliance calendar is a thin, declarative layer built on a proven stack:

Layer	Technology	Purpose
Front‑end	React (Vite bundler)	Interactive UI, route‑level code splitting
Back‑end	FastAPI	RESTful API, authentication, deadline aggregation
Storage	PostgreSQL	Persist deadline metadata, user preferences

The calendar component is served via a dedicated /api/deadlines endpoint. FastAPI handles authentication with JWTs issued by the same auth service used across DoAide products, ensuring that only authorized users can query deadlines relevant to their organization. Getting compliance management india right early saves rework later.

Backend Implementation

Below is a concise FastAPI route that returns deadlines for a tenant. The route demonstrates how deadlines are filtered by regulatory type (e.g., gst, roc) and grouped by month.

from fastapi import APIRouter, Depends
from pydantic import BaseModel
from datetime import date
from typing import List

router = APIRouter()

class Deadline(BaseModel):
    id: int
    title: str
    due_date: date
    category: str  # "gst", "roc", "fssai", etc.

@router.get("/deadlines", response_model=List[Deadline])
async def get_deadlines(user_id: int = Depends(get_current_user_id)):
    """Return all deadlines for the authenticated user."""
    query = (
        "SELECT id, title, due_date, category FROM deadlines "
        "WHERE tenant_id = $1 ORDER BY due_date"
    )
    rows = await db.fetch_all(query, user_id)
    return [Deadline(**row) for row in rows]

The SQL table is deliberately simple, yet expressive enough to support the calendar’s needs:

CREATE TABLE deadlines (
    id SERIAL PRIMARY KEY,
    tenant_id INT NOT NULL,
    title TEXT NOT NULL,
    due_date DATE NOT NULL,
    category TEXT NOT NULL,
    description TEXT,
    url TEXT
);

Each row represents a regulatory event. The category field allows the front‑end to filter or color‑code events (e.g., red for GST, blue for ROC). The url field can point to the filing portal or an internal compliance guide. Good compliance management india keeps the rest of the workflow predictable.

Front‑end Integration

The calendar UI uses a lightweight react-calendar component. The code below shows how deadlines are fetched, mapped to events, and rendered. The component is wrapped in a Suspense boundary to ensure that lazy route chunks load before the calendar is rendered, a change introduced in the recent commit (fix(seo): wait for lazy route chunks).

import { useEffect, useState, Suspense } from "react";
import Calendar from "react-calendar";
import axios from "axios";

interface Deadline {
  id: number;
  title: string;
  due_date: string; // ISO date
  category: string;
}

export default function ComplianceCalendar() {
  const [deadlines, setDeadlines] = useState<Deadline[]>([]);

  useEffect(() => {
    axios.get("/api/deadlines").then(res => setDeadlines(res.data));
  }, []);

  const events = deadlines.map(d => ({
    date: new Date(d.due_date),
    title: d.title,
    color: d.category === "gst" ? "#d32f2f" : d.category === "roc" ? "#1976d2" : "#388e3c"
  }));

  return (
    <Suspense fallback={<div>Loading calendar…</div>}>
      <Calendar
        tileContent={({ date }) => {
          const dayEvents = events.filter(e => e.date.toDateString() === date.toDateString());
          return dayEvents.length ? <div>{dayEvents.map(e => <span key={e.id} style={{background: e.color}}>{e.title}</span>)}</div> : null;
        }}
      />
    </Suspense>
  );
}

The calendar is responsive: touch targets are enlarged to 48 px (as per feat: 48px touch targets on touch devices), making it usable on mobile devices. The component also respects the teal theme introduced in the latest branding commit, ensuring visual consistency across the product. Treat compliance management india as a habit rather than a one-off task.

User Experience

When a user navigates to the Compliance Calendar page, the following steps occur:

Route Load – Vite serves the React bundle. Because the route is code‑split, the bundle is fetched lazily. The Suspense boundary ensures the calendar only renders after the bundle is ready.
Data Fetch – The component calls /api/deadlines. The server returns a list of deadlines sorted by due_date.
Rendering – Each deadline appears as a colored dot on its due date. Clicking the dot opens a modal with a brief description and a link to the filing portal.
Filtering – Users can toggle categories (GST, ROC, FSSAI) via a small sidebar. The filtering logic is implemented on the client; the back‑end simply returns all deadlines.
Notifications – The calendar component can be extended to schedule push notifications 7 days before a deadline. This feature is planned for a future release but is already supported by the existing data model.

The result is a single, audit‑ready view that satisfies the needs of compliance officers and CAs alike. By aggregating all regulatory obligations into one calendar, DoAide Comply removes the cognitive load of juggling multiple portals and spreadsheets.

Extensibility

Adding a new regulatory domain is straightforward. A new row is inserted into the deadlines table with the appropriate category. The front‑end automatically picks it up, applying the color mapping logic. The commit that added Industry Checklists (feat: FSSAI/labour/environmental checklists) demonstrates how the same table can be reused for checklist items that also have due dates.

Conclusion

The Compliance Calendar feature addresses the core challenge of regulatory tracking for Indian SMBs, chartered accountants, and compliance officers. By leveraging FastAPI, React, and PostgreSQL, DoAide Comply delivers a lightweight, maintainable solution that scales with the growing complexity of Indian compliance law. The feature exemplifies how a focused, data‑driven approach can replace fragmented spreadsheets and reduce the risk of costly penalties.

DEV Community