Chitty Fund Management System for a Registered Kerala Chitty Company (PHP/MySQL)

KuriFlow is a web application, built with PHP 8.3 and MySQL, that runs the monthly cycle of a registered chitty — the rotating-savings scheme Kerala households have trusted for generations. Under the Chit Funds Act, 1982, subscribers pay a fixed instalment every month; in a normal month the pot is auctioned, the lowest bidder takes the prize money (the chit amount minus the discount), the foreman keeps a capped commission, and the discount is returned to the remaining members as a dividend. Kerala's Registration Department now registers chitties online through its CORAL portal, yet inside most small companies the conduct of each chitty still lives in auction-minute books and ledger copies.

KuriFlow gives a chitty company one system for the whole cycle: define chitties (amount, subscriber count, duration, instalment, commission rate), enrol subscribers, record monthly payments, conduct the monthly auction, and let the engine compute prize money, commission and each non-prized subscriber's dividend exactly as the Act prescribes — commission capped at 5%, dividend credited in cash or against the next instalment. Prized subscribers' liability, arrears, passbooks and PDF statements all come from the same database, so any subscriber's question is answered in seconds.

The stack is deliberately syllabus-honest: PHP + MySQL (UK5DSCCAP300) with PDO, a small MVC core and server-rendered Bootstrap pages, plus FPDF and PHPUnit as labelled industry-standard extras. It is scoped as a 16-week, three-member Semester-8 project (12 credits) for the Kerala FYUGP BCA UK8RPHCAP400 / UK8CIPCAP400 slot.

A registered chitty company runs dozens of chitties in parallel, each with 20–50 subscribers and a monthly cycle of instalments, an auction, prize money, foreman commission and dividends. The company's working records are handwritten auction minutes and ledger copies: dividends for every non-prized subscriber are computed by hand every month, prized subscribers' continuing liability is tracked on separate cards, and arrears are found only when the treasurer finally totals the month. Disputes about what was bid, what was paid and what is owed are common; answering a subscriber's query means a page-by-page audit; and there is no consolidated evidence that the foreman's commission stayed within the statutory cap or that the discount was distributed as the Chit Funds Act, 1982 requires.

The problem is to build a secure, role-based web application that conducts each chitty's monthly cycle end to end — payments, auction, prize money, capped commission, dividend distribution, arrears and statements — with transaction-safe ledger writes and a complete audit trail, so every rupee in a chitty of any size can be explained from the database alone.

Abstract

Chitties remain one of Kerala's most used savings instruments: subscribers pool a fixed monthly instalment and take turns — by auction or lot — collecting the prize money, the foreman earns a capped commission, and non-prized subscribers share the discount as a dividend. A registered company conducts dozens of chitties in parallel, but the working records are usually handwritten auction minutes and carbon-copy ledgers, so dividends are recomputed by hand, arrears surface late, and subscriber queries mean page-by-page audits. This project builds KuriFlow, a PHP/MySQL web application managing chitty definition, enrolment, instalments, auctions, prize money, commission, dividends, arrears and statements under the Chit Funds Act, 1982.

Introduction

We interviewed the foreman of a fictional representative company — Anantha Chits & Investments, Thrissur (name invented) — running about forty chitties; the classic format: 25 subscribers, ₹2,00,000 chit amount, ₹8,000 instalment, 25 months. Each month the same questions repeat: who has paid, what each bidder offers, what the prized subscriber gets, what the other 24 are owed, and who is in arrears. The commission (up to 5%) must be separated from the discount before the dividend is shared, and prized subscribers must keep paying future instalments. Doing this on paper across forty groups consumes days every month and invites disputes.

Existing system and its limitations

• Auction minutes and ledger copies — no single source of truth; lost pages restart arguments.
• Dividends computed by hand per subscriber per month, often credited informally.
• Prized subscribers' liability on separate cards, so future instalments slip.
• Arrears visible only after the treasurer totals the month, usually post-auction.
• Subscriber queries need the foreman's personal attention each time.
• Regulatory bookkeeping — commission cap, Section 22 dividends — is asserted, not demonstrated from records.

Proposed system

• Chitty definition: chit amount, subscriber count, duration, instalment, start month, commission percentage (validated ≤ 5%) and auction method.
• Subscriber enrolment with name, address and phone (no government ID numbers stored).
• Instalment recording with receipt numbers and advance payments; dividends credited in cash or against the next instalment, as the Act allows.
• An auction module: each month records the bid, the prized subscriber and the discount; the engine computes prize money = chit amount − discount, foreman commission = rate × chit amount, and dividend = (discount − commission) ÷ non-prized subscribers, credited automatically to each non-prized subscriber's ledger.
• Arrears with a prized-subscriber liability view, member passbooks and PDF/CSV statements.
• Role-based access (Foreman/Admin, Branch staff, Subscriber) and an audit log of every financial change.

Feasibility study

• Technical: PHP + MySQL (UK5DSCCAP300) and DBMS (UK3DSCCAP201) cover everything — PDO transactions, foreign keys and unique constraints. FPDF and PHPUnit are mature open-source libraries.
• Economic: one shared-hosting account or the company's office PC with XAMPP; no licence cost.
• Operational: staff know the monthly sequence; the app mirrors it screen by screen.
• Schedule: 16 weeks — study and domain modelling, design, four build increments, testing, documentation.

In scope

• One chitty company with multiple parallel chitties (typical: 20–50 subscribers, 12–40 months, ₹50,000–₹10,00,000 chit amount).
• Roles: Foreman/Admin, Branch staff, Subscriber (read-only portal).
• Chitty definition, subscriber enrolment (no Aadhaar or government ID numbers stored), monthly instalments with receipts, tender/lot auctions, prize money, commission, dividends, arrears and passbooks.
• Dividend credit in cash or against the next instalment, per Section 22 of the Act.
• PDF statements via FPDF, CSV exports, and an audit log of every financial write.

Out of scope (v1)

• Online payment gateway collection (instalments are recorded against cash/bank receipts; a UPI flow is future scope).
• Auction bidding itself happens offline in the group's meeting; the app records the outcome, it does not host a live bidding room.
• Legal e-filing with the Registrar or CORAL integration, security/guarantor custody workflows, and auction forecasts using prediction models.
• Multi-company (multi-tenant) hosting.

The project follows an incremental SDLC model across the 16-week Semester-8 slot: the domain rules (Act arithmetic) are prototyped and unit-tested first, then the application is built in increments that each end in a demonstrable build reviewed by the guide.

Team split: Member 1 owns authentication, chitty definition and enrolment; Member 2 owns the payment ledger, arrears and statements; Member 3 owns the auction/dividend engine and audit log. Each member writes their own chapters and demonstrates their modules at the viva.

Testing approach: PHPUnit unit tests pin every Act formula (prize money, commission cap, dividend split, rounding to paise) against worked examples; integration tests drive HTTP flows against a seeded test database; black-box test cases per screen are tabulated (ID, input, expected, actual, status); and a concurrency test proves two simultaneous payment posts cannot double-credit.

KuriFlow uses a classic three-tier architecture on the LAMP pattern:

1. Presentation tier — server-rendered PHP pages styled with Bootstrap 5 (industry-standard extra), with vanilla JavaScript for table filtering and client-side validation. Subscribers get a read-only portal.
2. Application tier — a small MVC core: front controller, routers, controllers per module, service classes for the Act arithmetic, and PDO repositories. All money writes run inside InnoDB transactions; the commission cap and dividend split are enforced in a single service, never in view code.
3. Data tier — MySQL 8 with foreign keys, unique constraints (one auction per chitty-month, one instalment per subscriber-month) and DECIMAL columns for money.

flowchart TD
  F([Foreman / Admin]) --> B[Browser]
  S([Branch staff]) --> B
  M([Subscriber portal]) --> B
  B --> FC[Front controller / router]
  FC --> C1[Chitty & subscription controllers]
  FC --> C2[Payment & arrears controllers]
  FC --> C3[Auction / dividend service]
  C3 --> R[Act rules: commission cap, dividend split]
  C1 --> P[PDO repositories]
  C2 --> P
  C3 --> P
  P --> DB[(MySQL 8, InnoDB)]
  P --> AL[(Audit log)]
  P --> PDF[FPDF statements]

ER diagram

erDiagram
  USER ||--o{ SUBSCRIPTION : enrols
  CHITTY ||--|{ SUBSCRIPTION : "has"
  CHITTY ||--o{ AUCTION : "conducts"
  SUBSCRIPTION ||--o{ INSTALMENT : pays
  AUCTION ||--o{ DIVIDEND : "generates"
  SUBSCRIPTION ||--o{ DIVIDEND : "receives"
  SUBSCRIPTION ||--o{ PAYMENT : "makes"
  USER ||--o{ AUDIT_LOG : triggers

  USER {
    int id PK
    string name
    string email UK
    string passwordHash
    string role
  }
  CHITTY {
    int id PK
    string name
    decimal chitAmount
    int subscriberCount
    int durationMonths
    decimal instalment
    decimal commissionPct
    string auctionMethod
  }
  SUBSCRIPTION {
    int id PK
    int chittyId FK
    int userId FK
    int slotNo
    string status
  }
  INSTALMENT {
    int id PK
    int subscriptionId FK
    int monthNo
    decimal amount
    string status
  }
  AUCTION {
    int id PK
    int chittyId FK
    int monthNo
    int prizedSubscriptionId FK
    decimal bidDiscount
    decimal prizeMoney
    decimal commission
  }
  DIVIDEND {
    int id PK
    int auctionId FK
    int subscriptionId FK
    decimal share
    string creditMode
  }
  PAYMENT {
    int id PK
    int subscriptionId FK
    decimal amount
    string receiptNo UK
    date paidOn
  }
  AUDIT_LOG {
    int id PK
    int userId FK
    string action
    string detail
  }

• UPI collection flow so instalments can be paid in-app with automatic receipt reconciliation.
• Live tender-auction room with sealed bids inside the app for chitties that allow it.
• Security & guarantor custody tracking for prized subscribers, per the company's chit agreement.
• Integration hooks toward CORAL (Kerala Registration Department's chitty portal) for registration data exchange.
• Auction analytics — discount-trend models that help the foreman forecast likely future discounts and advise subscribers.