synopsis-file

byAbhishek Dhongade

based on the uploaded file that is my synopsis file so based on that create my mini project create based on the uploaded file

Landinglogin
Landing

Comments (0)

No comments yet. Be the first!

System Requirements

System Requirements Document for synopsis-file

1. Introduction

A / SYNOPSIS / ON / “ High-Volume Financial Transaction Management System ” / Submitted By / / Abhishek Balasaheb Dhongade (PRN: 2024011041021) / 2) Aryan Sameer Pathak (PRN: 2024011041072) / 3) Shivratna Sunil Jadhav (PRN: 2024011041035) / 4)Shrinath Bibhishan Tambe (PRN: 2025011042070) / 5)Avishkar Vishnupant Bedare (PRN: 2025011042043) / 6)Ritesh Rajendra Patil (PRN: 2024011041080) / / Under the Guidance of / Dr. Amit J. Chinchwade / / Department of Computer Science & Engineering (AI & ML) / School of Engineering & Technology / D. Y. Patil Agriculture & Technical University, Talsande / Academic Year / 2026-27

INDEX

SYNOPSIS

  1. Introduction :

  2. Literature Survey / Existing System :

The mini project is to be created based on the uploaded synopsis file, High_Volume_Financial_Transaction_Management_System__1__1_.docx. The chosen project name is synopsis-file.

1.1 Need for Proposed System

  1. Objectives :
Page 1 of 22

1.2 Any Other Requirement

  1. Planning of Work :

  2. Reference :

2. System Overview

Digital banking, online shopping and payment applications generate large numbers of financial transactions. A transaction management system must record each request correctly, update account balances safely and provide a clear status even when many users access the system at the same time.

As transaction volume increases, a simple application can face slow responses, database contention and difficult recovery after failures. Network timeouts may also cause users to retry a request. Without duplicate protection, the same request could be processed more than once and produce incorrect financial records.

To address these challenges, we propose “High-Volume Financial Transaction Management System”. The system will provide authenticated account access, simulated fund transfers, transaction tracking and an administration dashboard. A Python FastAPI backend and PostgreSQL database will maintain a double-entry ledger, while Apache Kafka will support asynchronous events and background reporting.

Page 2 of 22

2.1 Existing System

Existing approaches to financial transaction management include:

  • Database-centred applications that process requests synchronously and maintain account and transaction tables.

  • Batch-processing systems that collect records and prepare settlements or reports at scheduled intervals.

  • Event-driven systems that use durable message streams and independent background workers.

PostgreSQL documentation describes transaction isolation and the need to retry serialization failures [1]. Apache Kafka documentation explains durable messaging, idempotent producers and transactional processing within Kafka [2]. These features support reliability, but database updates and message delivery still require applicationlevel coordination. OWASP provides guidance for secure transaction authorization [3].

2.2 Limitations of Existing System

  1. Simple synchronous designs may become bottlenecks during sudden traffic peaks.
Page 3 of 22

2.3 Need for Proposed System

The proposed system combines a consistent ledger, duplicate protection, asynchronous events, audit trails and a web dashboard. It aims to demonstrate reliable processing under a documented test workload, without claiming to replace production banking infrastructure.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

The proposed system combines a consistent ledger, duplicate protection, asynchronous events, audit trails and a web dashboard. It aims to demonstrate reliable processing under a documented test workload, without claiming to replace production banking infrastructure.

  1. Problem Statement :

A financial transaction management system must process many simultaneous requests without losing records, duplicating transfers or creating incorrect balances. As demand grows, database contention, retries and service interruptions make it difficult to maintain both responsive operation and reliable financial records.

The main problems are:

  • Handling concurrent transfers while preserving balance and ledger consistency.

  • Preventing duplicate processing when requests or events are retried.

  • Recovering from failures without leaving a partial debit or credit.

Page 4 of 22
  • Tracking pending, completed and failed transactions with a clear history.

  • Protecting financial operations through authentication and authorization.

  • Measuring throughput and latency under realistic, repeatable load.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

3. Functional Requirements

Each transfer will use database transactions, controlled concurrent updates and a unique idempotency key. Debit and credit entries will be committed together, and monetary values will use fixed-precision decimal representation. Audit records and reconciliation checks will help identify failures and inconsistencies.

3.1 Limitations of Existing System

  1. Poorly coordinated concurrent updates can produce inconsistent balances.

  2. Retries without idempotency checks may create duplicate financial effects.

  3. Batch-only reporting can delay visibility of pending or failed transactions.

  4. Disconnected audit records make tracing and reconciliation difficult.

Page 5 of 22

3.2 Need for Proposed System

The proposed system combines a consistent ledger, duplicate protection, asynchronous events, audit trails and a web dashboard. It aims to demonstrate reliable processing under a documented test workload, without claiming to replace production banking infrastructure.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

The proposed system combines a consistent ledger, duplicate protection, asynchronous events, audit trails and a web dashboard. It aims to demonstrate reliable processing under a documented test workload, without claiming to replace production banking infrastructure.

  • Measuring throughput and latency under realistic, repeatable load.

A financial transaction management system must process many simultaneous requests without losing records, duplicating transfers or creating incorrect balances. As demand grows, database contention, retries and service interruptions make it difficult to maintain both responsive operation and reliable financial records.

  • Handling concurrent transfers while preserving balance and ledger consistency.
Page 6 of 22

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

A financial transaction management system must process many simultaneous requests without losing records, duplicating transfers or creating incorrect balances. As demand grows, database contention, retries and service interruptions make it difficult to maintain both responsive operation and reliable financial records.

  • Preventing duplicate processing when requests or events are retried.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

A financial transaction management system must process many simultaneous requests without losing records, duplicating transfers or creating incorrect balances. As demand grows, database contention, retries and service interruptions make it difficult to maintain both responsive operation and reliable financial records.

  • Recovering from failures without leaving a partial debit or credit.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

Page 7 of 22
  • Tracking pending, completed and failed transactions with a clear history.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

  • Protecting financial operations through authentication and authorization.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

  • Measuring throughput and latency under realistic, repeatable load.

Therefore, there is a need to develop a scalable transaction management prototype that validates requests, maintains an atomic double-entry ledger, supports safe retries and provides an accessible monitoring interface. The system must retain an audit history and verify that every committed transfer remains financially balanced.

The main objectives of the High-Volume Financial Transaction Management System are:

  1. To design a consistent financial data model. Create account, transfer, ledger and audit tables using fixed-precision monetary values, unique identifiers and integrity constraints.

The main objectives of the High-Volume Financial Transaction Management System are:

Page 8 of 22
  1. To implement safe transaction processing. Validate requests and permissions, check available balances, and commit debit and credit entries atomically with concurrency control.

The main objectives of the High-Volume Financial Transaction Management System are:

  1. To support high request volumes and safe retries. Use indexed queries, connection pooling, idempotency keys and Kafka-based background processing with duplicate protection.

The main objectives of the High-Volume Financial Transaction Management System are:

  1. To provide security and operational visibility. Add role-based access, protected APIs, transaction search, audit trails, reconciliation checks and an administration dashboard.

  2. Software Requirement Specification :

The system must provide the following functions:

User and Account Module:

  • Create simulated accounts and display balances and transaction history.

The system must provide the following functions:

Transaction Processing Module:

  • Authenticate users and administrators with role-based permissions.

  • Validate account details, currency, positive amount and available balance.

  • Commit balanced debit and credit entries in one database transaction.

Page 9 of 22
  • Use idempotency keys and unique constraints to prevent duplicate transfers.

  • Handle concurrent updates and retry transient conflicts within defined limits.

Event Processing Module:

  • Write an outbox record with the transfer; publish committed events to Kafka.

  • Make consumers idempotent and isolate repeatedly failed events for review.

Monitoring and Reporting Module:

  • Search transactions by reference, account, status and date range.

  • Show throughput, response times, failures and reconciliation differences.

Audit and Recovery Module:

  • Record actor, timestamp and outcome for significant operations.

  • Support backup restoration tests and linked reversal entries without deleting posted ledger history.

Page 10 of 22

3.3 User Interface Requirement

The web application must:

  • Provide login, account overview, transfer form and transaction history pages.

  • Show recipient, amount and currency for confirmation before submission.

  • Display a transaction reference and distinguish accepted, pending, completed and failed states.

  • Provide an administrator dashboard with filters, audit views and system metrics.

4. User Personas

4.1 Any Other Requirement

Project Guide Project Coordinator Head of Department

5. Core User Flows

The flows below cover the accepted goals of the High-Volume Financial Transaction Management System. Each is independent; the system does not impose an ordering between them beyond the authentication and role checks described in the access requirements.

Page 11 of 22

5.1 Authenticated access to accounts

Actor: Account holder (user) or administrator. Trigger: The user opens the web application.

  1. The user submits credentials on the login page.
  2. The system authenticates the user and applies role-based permissions, distinguishing account holders from administrators.
  3. On success, the user reaches the account overview showing balances and transaction history; administrators reach the administration dashboard.

Failure/recovery: Invalid credentials are rejected and the user remains on the login page to retry. A user without the administrator role cannot reach dashboard functions.

Page 12 of 22

5.2 Simulated fund transfer

Actor: Account holder. Trigger: The user chooses to move funds between simulated accounts.

  1. The user opens the transfer form and enters recipient, amount and currency.
  2. The system validates account details, currency, a positive amount and available balance.
  3. The system shows recipient, amount and currency for confirmation before submission.
  4. On confirmation, the system commits a balanced debit and credit entry in one database transaction (atomic double-entry ledger) and returns a transaction reference.
  5. The transaction is recorded with a state the user can follow: accepted, pending, completed or failed.

Failure/recovery: Validation failures (unknown account, unsupported currency, non-positive amount, insufficient balance) stop the transfer before any ledger entry. Safe retries are supported so a repeated submission does not duplicate a transfer. A failed transaction remains visible in history with its reference.

Continuation: The user can open transaction history to track the transfer's state and confirm completion.

Page 13 of 22

5.3 Transaction tracking and history

Actor: Account holder. Trigger: The user wants visibility of past and in-flight transfers.

  1. The user opens the transaction history page.
  2. The system lists transactions with their references and states (accepted, pending, completed, failed).
  3. The user inspects a transaction to see its details and current state.

Continuation: Pending transactions update as asynchronous events and background reporting progress them to completed or failed.

5.4 Administration and operational visibility

Actor: Administrator. Trigger: The administrator needs oversight of system activity.

  1. The administrator signs in with administrator permissions and opens the administration dashboard.
  2. The dashboard presents filters, audit views and system metrics.
  3. The administrator searches transactions, reviews audit trails and runs reconciliation checks that verify every committed transfer remains financially balanced.

Failure/recovery: Reconciliation checks surface any imbalance for investigation; audit history is retained so the discrepancy can be traced.

Page 14 of 22

5.5 Load measurement

Actor: Administrator (or test operator). Trigger: The need to measure throughput and latency.

  1. A documented, repeatable test workload is applied to the system.
  2. The system processes concurrent transfers while preserving balance and ledger consistency.
  3. Throughput and latency results are observed through the dashboard metrics.

Note: This flow demonstrates reliable processing under a documented test workload; the prototype does not claim to replace production banking infrastructure.

Page 15 of 22

6. Visuals Colors and Theme

[Design proposal; unspecified choices are defaults.]

Muse and headline. Josef Müller-Brockmann governs the visual system: Swiss geometric rigour for a balanced ledger. The public entry headline is Every transfer stays balanced, with subline A double-entry ledger prototype with safe retries, audit history and a monitoring dashboard. and call to action Open the ledger.

Colour tokens (light mode). Background #F4F1EA (warm paper ground); surface #FFFFFF; text #111111; primary #E03C00 (signal orange — primary action and debit); accent #1B4D8F (coded blue — credit and admin state); muted #6B6B66. No gradients, no blue-on-white default buttons.

Typography. Archivo throughout. Headings Archivo Heavy 800, flush left, tight tracking, large scale contrast; small-caps labels at 600 weight. Body Archivo. Modular scale 1.333 — 64/40/28/18/15, with display type from 40px mobile to 96px desktop via clamp(...).

Shape and surface. Hard edges only. Thin black rules divide columns; solid rectangles and circles act as state codes. No rounded cards, no soft shadows.

Layout. Strict 12-column grid with visible horizontal rules; asymmetric poster blocks; label/value pairs aligned in tables. Balance figures use tabular numerals in a bordered column, never cards.

Imagery. Abstract geometry only — ruled diagrams of the ledger flow, cropped to the grid. No photography, no decorative illustration.

Page 16 of 22

Readability guard. Headlines, wordmarks, labels, numbers and controls stay whole inside the viewport and their container at 375px, 768px and 1280px; decoration may bleed or overlap but never covers readable text or a control. The usability requirement holds across the dashboard and transfer flows: clear validation errors, confirmation screens and readable transaction statuses.

7. Signature Design Concept

[Design proposal; unspecified choices are defaults.]

Signature moves. An oversized orange circle overlaps the right grid edge behind the headline. A ruled state strip shows pending, completed and failed as coded colour squares. Balance figures sit in a bordered tabular-numeral column. Section openers use a full-width black rule with a small-caps section number.

Public entry composition. Full-width paper ground. A black 96px headline occupies nine columns; the huge orange circle sits at the right edge behind it. Under the headline, a ruled state table runs in three columns — pending, completed, failed — each state carried by its coded square, so the ledger's defining states are legible before any interaction. The Open the ledger action is a solid orange rectangle, flush left, never centred.

Avoid. Rounded cards with soft shadows; gradient backgrounds; centred hero copy; decorative illustration; blue-on-white default buttons.

Page 17 of 22

8. Interaction Model & Motion Direction

[Design proposal; unspecified choices are defaults.]

Interaction Model: Static (direction) Motion Tempo: restrained Hero Dimensionality: flat

Landing Hero Motion Brief. Focal subject: the oversized orange circle and the ruled three-column state strip. Thesis: on load, balance figures count once from zero to their committed value in tabular numerals, then hold; the state strip's coded squares switch instantly between pending, completed and failed with no easing flourish, mirroring the ledger's instant state changes. Motion vocabulary is restrained — a single count-on-load, hard cuts thereafter. Composed first frame: paper ground, black headline in nine columns, orange circle at the right edge, ruled state table beneath. Reduced-motion state: figures render at final value immediately and the state strip is static; no counting, no transitions.

9. Non-Functional Requirements

The project will be evaluated using synthetic financial records and repeatable load tests. Throughput, response time, error rate and ledger consistency will be measured rather than assumed. This academic prototype will use simulated balances; it will not connect to live banking networks or handle real customer funds.

Page 18 of 22

9.1 Need for Proposed System

  • Measuring throughput and latency under realistic, repeatable load.

The main objectives of the High-Volume Financial Transaction Management System are:

  1. To test and deploy the prototype. Use synthetic data and load tests to measure throughput, percentile latency, error rate and recovery behaviour, then deploy a reproducible container-based demonstration.

  2. Security: Use HTTPS when deployed, strong password hashing, server-side authorization and input validation. Exclude secrets and sensitive credentials from logs.

  3. Consistency: Preserve atomic posting and balanced ledger entries. Store money as fixed-precision decimals, not binary floating-point values.

  4. Reliability: Persist accepted work before acknowledging it. Recover pending work after interruption and handle retries without repeated financial effects.

  5. Scalability: Allow API and background-worker capacity to grow independently.

Measure the database and queue bottlenecks before increasing load.

  1. Usability: Provide clear validation errors, confirmation screens and readable transaction statuses.

  2. Maintainability: Separate account, ledger, event and interface components.

Maintain tests, API documentation and version-controlled database migrations.

Page 19 of 22

9.2 User Interface Requirement

  • Work on mobile phones and standard desktop browsers.

9.3 Performance Requirement

  • Provisional target: 100 transfer requests per second with 95th-percentile API response time below 2 seconds during a 10-minute controlled test.

  • Report hardware, dataset size, concurrency, queue lag, end-to-end posting latency and error rate. These targets are not measured results.

  • Require zero duplicate postings and zero unbalanced committed transfers in concurrency, retry and recovery tests.

10. Tech Stack

10.1 Hardware & Software Requirement

Software Requirements:

  • Operating System: Windows / Linux.

  • Programming Language and Backend: Python, FastAPI and SQLAlchemy.

  • Database and Messaging: PostgreSQL and Apache Kafka.

  • Frontend: HTML, CSS and JavaScript.

  • Testing and Monitoring: Pytest, Locust, Prometheus and Grafana.

  • Container and Tools: Docker, Docker Compose, VS Code and Git/GitHub.

Page 20 of 22

11. Assumptions and Constraints

The project will be evaluated using synthetic financial records and repeatable load tests. Throughput, response time, error rate and ledger consistency will be measured rather than assumed. This academic prototype will use simulated balances; it will not connect to live banking networks or handle real customer funds.

11.1 Limitations of Existing System

  1. Poorly coordinated concurrent updates can produce inconsistent balances.

  2. Retries without idempotency checks may create duplicate financial effects.

  3. Batch-only reporting can delay visibility of pending or failed transactions.

  4. Disconnected audit records make tracing and reconciliation difficult.

11.2 Hardware & Software Requirement

Hardware Requirements:

  • Minimum 8 GB RAM; 16 GB recommended for the complete local stack.

  • Multi-core processor, SSD storage and a stable network connection.

  • Separate load-generator resources for representative performance testing.

  • Test Data: Synthetic accounts, opening balances and generated transfer requests; no real financial credentials.

Page 21 of 22

11.3 Any Other Requirement

  • Limit the initial version to simulated internal transfers in one currency. Live banking integration and production compliance are outside scope.

  • Future scope: approved payment-gateway integration, fraud alerts and multicurrency accounting after separate security and compliance review.

Documentation reviewed for transaction isolation, event-delivery guarantees and secure authorization. Performance figures in this synopsis are proposed acceptance targets and must be verified through testing.

12. Glossary

12.1 Any Other Requirement

  1. PostgreSQL Global Development Group, “Transaction Isolation,” PostgreSQL Official Documentation. https://www.postgresql.org/docs/current/transactioniso.html

  2. Apache Software Foundation, “Design: Message Delivery Semantics,” Apache Kafka

Official Documentation. https://kafka.apache.org/43/design/design/

  1. OWASP Foundation, “Transaction Authorization Cheat Sheet,” OWASP Cheat Sheet Series.

https://cheatsheetseries.owasp.org/cheatsheets/Transaction_Authorization_Cheat_S heet.html

Page 22 of 22
Live
Landing design preview

user opens login

invalid credentials

retry login

authentication succeeds

user chooses to transfer funds

inputs valid

validation failure

corrected inputs

user confirms

transfer committed

user opens history

user opens history

user inspects transaction

Landing: Open the ledger

login: 1. Submit credentials

login: 2. Retry after invalid credentials

account overview: View balances and history

transfer form: 1. Enter recipient, amount, currency

transfer form: Review confirmation details

transfer form: 2. Correct validation errors

transfer form: Confirm and submit transfer

transfer form: Note transaction reference

transaction history: Track transaction state

transaction history: Inspect transaction details

Live
Landing design preview

user opens login

invalid credentials

retry login

authentication succeeds

user chooses to transfer funds

inputs valid

validation failure

corrected inputs

user confirms

transfer committed

user opens history

user opens history

user inspects transaction

Landing: Open the ledger

login: 1. Submit credentials

login: 2. Retry after invalid credentials

account overview: View balances and history

transfer form: 1. Enter recipient, amount, currency

transfer form: Review confirmation details

transfer form: 2. Correct validation errors

transfer form: Confirm and submit transfer

transfer form: Note transaction reference

transaction history: Track transaction state

transaction history: Inspect transaction details