PSAK Financial Report Automation: A Practical Guide for Health Information Systems
T
Kembali ke Blog

PSAK Financial Report Automation: A Practical Guide for Health Information Systems

Tutorial
Tim Pilar Inovasi 20 Aug 2026 18 min baca 3,990 kata 220
Learn how to build a PSAK-compliant financial report automation system for hospitals and clinics. This article covers the concepts, technical implementation with code examples, and best practices for IT managers and healthcare facility owners.

Financial report management in healthcare facilities such as hospitals and clinics is one of the largest operational challenges. Manual processes that are still widely applied often take hours, are prone to human error, and are difficult to guarantee full compliance with the continually evolving Statement of Financial Accounting Standards (PSAK). Imagine a scenario where an operations manager has to wait weeks to get an accurate statement of financial position, while strategic decisions must be made immediately. Or an IT manager who is frustrated because the existing SIMRS system is not seamlessly integrated with the accounting module, causing duplicate input and data inconsistency. Patient transaction data, drug inventory, BPJS payments, and employee payroll must be recorded, journalized, and reconciled carefully. Without an automated system, the risk of audits, fines, and financial losses due to delayed or inaccurate decisions becomes very high. This article serves as a practical and in-depth guide to building a financial report automation system that is not only efficient but also fully PSAK-compliant. We will discuss everything from the basics of accounting, a robust system architecture, examples of technical implementation with runnable code, to best practices and error handling, specifically designed for IT managers, clinic owners, and decision-makers who need concrete and actionable technology solutions.

Understanding the Basics of Financial Reports & PSAK in the Healthcare Context

The Statement of Financial Accounting Standards (PSAK) is the accounting guideline applicable in Indonesia, issued by the Indonesian Institute of Accountants (IAI). For healthcare facilities, whether nonprofit or profit-oriented, compliance with PSAK is crucial for transparency, accountability, and sound decision-making. The main financial statements that must be prepared include the Statement of Financial Position (Balance Sheet), the Statement of Profit or Loss and Other Comprehensive Income, the Statement of Cash Flows, and the Notes to Financial Statements (CALK). Each statement has specific purposes and formats governed by PSAK, for example PSAK 1 (Presentation of Financial Statements), PSAK 2 (Statement of Cash Flows), or PSAK 10 (The Effects of Changes in Foreign Exchange Rates). Compliance with these standards is important not only for external audits but also for providing a picture of the entity's financial health to management, investors, and other stakeholders.

The unique challenge in the healthcare sector lies in the complexity of revenue and cost sources. Revenue can come from general patients, BPJS Kesehatan, private insurance, or corporations, each with different billing and revenue recognition schemes. Operating costs include salaries of medical personnel, purchase of drugs and medical devices, utility costs, and depreciation of fixed assets such as MRI or CT-Scan machines. Each of these transactions must be recorded accurately and classified into the correct account in the Chart of Accounts (COA) or Standard Chart of Accounts. A concrete example: when a BPJS patient receives services, a series of journal entries must be generated: recognition of medical service revenue, BPJS receivables, use of drug inventory, and medical personnel costs. All of this must be automated from the daily transaction data of the SIMRS or Clinic SIM.

To ensure PSAK compliance, the automation system must be able to handle accrual-based revenue recognition, recording expenses according to the matching cost with revenue principle, managing fixed assets and their depreciation, and automatic bank and cash reconciliation. For example, PSAK 10 regarding the effects of changes in foreign exchange rates will be relevant if a hospital imports medical devices. The system must be able to journal the exchange differences that arise. Likewise, PSAK 14 on Inventories will govern how drug and medical device inventory is valued and recorded, whether using the FIFO or Average method. The automation system must be configured to follow the method chosen by the entity.

The need for granular data is key. Every transaction detail, from patient ID, type of service, quantity of drugs used, to payment method, must be recorded and traceable down to the accounting journal. This is not only for reporting purposes but also for profitability analysis per service or per department. Without automation, this process becomes an inefficient nightmare, slowing down critical decision-making and increasing the risk of non-compliance. Building a strong foundation with a correct understanding of PSAK is the first non-negotiable step.

Financial Report Automation System Architecture

Building a robust financial report automation system requires a well-planned architecture. Broadly speaking, this system consists of several key components: Data Sources, the ETL (Extract, Transform, Load) or Data Processing Layer, the Accounting Engine, the Reporting Layer, and the Database. The integration among these components is the heart of automation, ensuring a smooth and consistent flow of data from operational transactions to the final financial statements. Choosing the right technology will greatly affect the system's scalability, maintainability, and performance.

For the Database, we highly recommend using PostgreSQL 16. PostgreSQL is a highly reliable open-source relational database management system (RDBMS), ACID-compliant (Atomicity, Consistency, Isolation, Durability), and has extensive capabilities for handling complex data and high-volume transactions. Features such as JSONB, CTEs (Common Table Expressions), and advanced indexing capabilities are very helpful in managing diverse transaction data and generating complex reports. For the backend layer or Accounting Engine, Python with the Django 5.x framework is a very solid choice. Django provides a powerful ORM (Object-Relational Mapper), a fast admin system, and an organized project structure, ideal for building complex accounting logic and APIs for integration. Another alternative could be using Laravel 11.x (PHP) or Node.js with Express.js, depending on the team's preference.

Data integration from Data Sources, such as SIMRS (for example, applications that use HL7 v2.5.1 or FHIR R4 for interoperability) or Clinic MIS, can be done through several methods. The most common is through RESTful APIs provided by the SIMRS. If the SIMRS does not have an API, another option is a direct database connection (with great care and permission), or the use of message queues such as RabbitMQ or Apache Kafka for very high-volume and asynchronous data scenarios. The extracted data will then pass through the ETL layer. Here, raw data from operational transactions (for example, patient registration, medical procedures, drug prescriptions, payments) will be transformed into a format suitable for accounting journals, mapping transactions to the relevant COA accounts.

The core data model in this automation system will include the Chart of Accounts (COA), Journal Entries, and General Ledger. The COA is the foundation, defining all the accounts used (for example, Cash, Accounts Receivable, Service Revenue, Salary Expense). Each operational transaction will trigger the creation of one or more journal entries that record debits and credits to the appropriate accounts. From these journal entries, the system will automatically post to the general ledger, which then becomes the basis for generating financial reports. The Reporting Layer can be built using custom HTML/PDF templates generated by Django, or integrated with Business Intelligence (BI) tools such as Metabase or Apache Superset for more interactive data visualization and in-depth analysis. This entire flow ensures that data flows automatically from the transaction point to becoming a report ready to be presented, significantly reducing manual intervention and the risk of errors.

Technical Implementation: Data Engineering & Automatic Journals

A crucial step in automating financial reports is how operational transaction data is converted into accounting journal entries that comply with the debit-credit principle. This process involves careful 'data engineering' to extract relevant data, transform it, and load it into the accounting system. We will use Python with the Django ORM to define the journal model and functions to process transactions. We assume we have an `Account` model that represents the Chart of Accounts (COA) with attributes such as `code`, `name`, `account_type` (for example, Asset, Liability, Revenue, Expense).

First, let us define the model for journal entries. Each transaction will produce one `JournalEntry` that may have several `JournalItems` (one for debit, one for credit, or more if there are accounts involved). This allows flexibility for complex transactions. The following is an example of a Django model:

# accounting/models.pyimport uuidfrom django.db import modelsclass Akun(models.Model):    KATEGORI_AKUN = [        ('A', 'Aset'),        ('L', 'Liabilitas'),        ('E', 'Ekuitas'),        ('P', 'Pendapatan'),        ('B', 'Beban'),    ]    kode = models.CharField(max_length=20, unique=True, help_text="Kode akun sesuai COA (misal: 11001)")    nama = models.CharField(max_length=100, help_text="Nama akun (misal: Kas di Bank)")    kategori = models.CharField(max_length=1, choices=KATEGORI_AKUN, help_text="Kategori akun")    saldo_normal = models.CharField(max_length=10, choices=[('D', 'Debit'), ('K', 'Kredit')], help_text="Saldo normal akun")    def __str__(self):        return f"[{self.kode}] {self.nama}"class JurnalEntry(models.Model):    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)    tanggal = models.DateField(help_text="Tanggal transaksi")    deskripsi = models.TextField(help_text="Deskripsi singkat transaksi")    referensi_dokumen = models.CharField(max_length=100, blank=True, null=True, help_text="Nomor invoice, ID transaksi SIMRS")    created_at = models.DateTimeField(auto_now_add=True)    updated_at = models.DateTimeField(auto_now=True)    def __str__(self):        return f"Jurnal {self.id} - {self.tanggal}"class JurnalItem(models.Model):    jurnal_entry = models.ForeignKey(JurnalEntry, related_name='items', on_delete=models.CASCADE)    akun = models.ForeignKey(Akun, on_delete=models.PROTECT)    debit = models.DecimalField(max_digits=18, decimal_places=2, default=0)    kredit = models.DecimalField(max_digits=18, decimal_places=2, default=0)    def __str__(self):        return f"{self.akun.nama}: D={self.debit}, K={self.kredit}"

Explanation: The `Akun` model stores the details of the Chart of Accounts. `JurnalEntry` is the header for a set of transactions, while `JurnalItem` is the debit or credit line that refers to a specific account. The `saldo_normal` field in `Akun` is very important for validation and ensuring debit-credit balance. The `referensi_dokumen` field serves for traceability, linking the journal back to the original transaction in the SIMRS.

Next, we will create a Python function that receives payment transaction data from the SIMRS and automatically creates the appropriate journal entries. Suppose we receive payment data in JSON format. This function will look up the relevant accounts based on configuration and create debit/credit journals.

# accounting/services.pyfrom decimal import Decimalfrom django.db import transactionfrom .models import Akun, JurnalEntry, JurnalItemdef create_payment_journal(payment_data: dict):    """    Creates journal entries for payment transactions.    payment_data: dict containing 'tanggal', 'jumlah', 'metode_pembayaran', 'referensi_transaksi', 'layanan_id'    Example:    {        'tanggal': '2023-10-26',        'jumlah': 1500000.00,        'metode_pembayaran': 'Tunai',        'referensi_transaksi': 'INV-20231026-001',        'layanan_id': 'SVC-005'    }    """    try:        with transaction.atomic():            # 1. Create a new JurnalEntry            jurnal_entry = JurnalEntry.objects.create(                tanggal=payment_data['tanggal'],                deskripsi=f"Pembayaran layanan {payment_data.get('layanan_id', '')} via {payment_data['metode_pembayaran']}",                referensi_dokumen=payment_data['referensi_transaksi']            )            # 2. Determine the Debit (Cash/Bank) and Credit (Revenue) accounts            # Assumption: 'Kas' and 'Pendapatan Pelayanan' accounts already exist in the COA            # In a real implementation, this could be taken from configuration or dynamic mapping            if payment_data['metode_pembayaran'] == 'Tunai':                akun_kas_bank = Akun.objects.get(kode='11101') # Example Cash account code                akun_pendapatan = Akun.objects.get(kode='41101') # Example Service Revenue account code            elif payment_data['metode_pembayaran'] == 'Transfer Bank':                akun_kas_bank = Akun.objects.get(kode='11102') # Example Bank account code                akun_pendapatan = Akun.objects.get(kode='41101') # Example Service Revenue account code            else:                raise ValueError(f"Metode pembayaran tidak dikenal: {payment_data['metode_pembayaran']}")            jumlah = Decimal(str(payment_data['jumlah']))            # 3. Create JurnalItem for Debit            JurnalItem.objects.create(                jurnal_entry=jurnal_entry,                akun=akun_kas_bank,                debit=jumlah,                kredit=Decimal('0.00')            )            # 4. Create JurnalItem for Credit            JurnalItem.objects.create(                jurnal_entry=jurnal_entry,                akun=akun_pendapatan,                debit=Decimal('0.00'),                kredit=jumlah            )            return jurnal_entry    except Akun.DoesNotExist as e:        raise ValueError(f"Akun tidak ditemukan dalam Chart of Accounts: {e}")    except Exception as e:        raise RuntimeError(f"Gagal membuat jurnal pembayaran: {e}")

Explanation: The `create_payment_journal` function receives a `payment_data` dictionary. Using `transaction.atomic()` ensures that all database operations (creating the `JurnalEntry` and two `JurnalItem`s) succeed or fail together, maintaining data integrity. This function dynamically determines the Cash/Bank account based on the payment method and the Service Revenue account. In real scenarios, this account mapping may be more complex, involving configuration based on service type or department. It is important to ensure that the referenced accounts (`kode='11101'`, `kode='41101'`) already exist in your COA database before running this function. Otherwise, `Akun.DoesNotExist` will be triggered. With these two code blocks, we have laid the foundation for converting operational transaction data into automatic and structured accounting journal entries.

Example Data Payload & Error Handling

Integration between operational systems (SIMRS/SIM Klinik) and automated accounting systems often involves data exchange via API. Understanding the expected data payload structure and how to handle errors is essential for building a robust system. Below is an example of a realistic JSON payload representing a payment transaction from the SIMRS, followed by an example error message and handling strategy.

{  "transaction_id": "TRX-SIMRS-20231026-001",  "patient_id": "PT-2023-00123",  "service_date": "2023-10-25",  "payment_date": "2023-10-26",  "total_amount": 1850000.00,  "paid_amount": 1850000.00,  "payment_method": "Transfer Bank BCA",  "invoice_number": "INV/RSU/10/2023/00567",  "items": [    {      "item_id": "SVC-LAB-001",      "description": "Pemeriksaan Darah Lengkap",      "quantity": 1,      "unit_price": 350000.00,      "subtotal": 350000.00    },    {      "item_id": "SVC-DR-005",      "description": "Konsultasi Dokter Spesialis Penyakit Dalam",      "quantity": 1,      "unit_price": 1000000.00,      "subtotal": 1000000.00    },    {      "item_id": "MED-PAR-010",      "description": "Obat Paracetamol 500mg",      "quantity": 2,      "unit_price": 250000.00,      "subtotal": 500000.00    }  ],  "notes": "Pembayaran lunas untuk layanan rawat jalan"}

The payload above includes detailed payment transaction information, including the unique transaction ID, patient ID, service and payment dates, total amount, payment method, invoice number, and details of the service/product items. This data will be processed by the `create_payment_journal` function (or a similar, more complex function) to generate accurate journal entries, for example debiting the Cash/Bank account and crediting the Medical Services Revenue, Pharmacy Revenue, or Laboratory Revenue accounts according to the existing items. It is important to map `item_id` to the specific revenue account in your COA.

However, in any integration, errors are inevitable. One example of a frequently occurring error is invalid data or a missing reference. Suppose the system tries to journal a transaction for an account that is not registered in the configured Chart of Accounts (COA). An example error message that might appear from the automated accounting system:

{  "error_code": "ACCOUNT_NOT_FOUND",  "message": "Failed to process transaction TRX-SIMRS-20231026-001: Account 'Pharmacy Revenue' with code 42101 was not found in the Chart of Accounts. Please check the COA configuration or account mapping.",  "timestamp": "2023-10-26T14:35:01Z",  "transaction_payload": {    "transaction_id": "TRX-SIMRS-20231026-001",    "item_id_causing_error": "MED-PAR-010"  }}

Effective error handling is very important to maintain data integrity and operational smoothness. Here are several strategies:

  1. Data Validation at the Ingestion Layer: Before data is processed further, perform strict validation of the received payload. Ensure that all required fields are filled in, the data format is correct (for example, the amount is a positive numeric value), and key references (such as `item_id` or `patient_id`) are valid. Use a validation schema (for example, JSON Schema) to ensure consistency.
  2. Transaction Management: Use database transactions (such as `with transaction.atomic()` in Django) to ensure that a series of operations related to one journal entry is atomic. If one part fails, the entire transaction is rolled back, preventing partial or inconsistent data from entering the database.
  3. Structured Logging: Implement comprehensive logging using a structured format (for example, JSON) that records error details, timestamps, transaction IDs, and the payload causing the problem. This facilitates debugging and root cause analysis. Logs must be stored in a centralized location (for example, ELK stack or Splunk).
  4. Alerting System: Configure an alerting system (for example, via email, Slack, or PagerDuty) for instant notification when critical errors occur, especially those related to journal creation failures. Notifications must include essential information so that the IT or accounting team can act immediately.
  5. Retry Mechanism: For transient errors (for example, network connection issues or a busy database), implement a retry mechanism with exponential backoff. This allows the system to try processing the transaction again after a certain delay, reducing the need for manual intervention.
  6. Dead-Letter Queue (DLQ): For messages that fail to be processed after several retries, route them to a Dead-Letter Queue. This is a separate queue where problematic messages are stored for further manual investigation, preventing those messages from blocking the main queue.
  7. Graceful Degradation: In the event of an accounting system failure, ensure that the operational system (SIMRS) can continue running. Transaction data can be stored temporarily in SIMRS and processed in batches after the accounting system recovers, or replayed from the transaction log.

By implementing these error handling strategies, the financial report automation system will become more resilient, reduce downtime, and ensure the integrity of financial data, even when facing unexpected conditions.

Best Practices in PSAK Financial Report Automation

  1. Design a Comprehensive Chart of Accounts (COA) in Accordance with PSAK: Ensure that your COA not only includes all necessary account categories (Assets, Liabilities, Equity, Revenue, Expenses) but also has sufficient detail to meet internal and external reporting needs in accordance with PSAK. Consult with a professional accountant to ensure each account is mapped correctly and ready to produce standard financial statements. A good COA structure will be the foundation for report accuracy.
  2. Implement Strong Data Validation at Every Stage: Validation must be applied from the data source (SIMRS/SIM Klinik) to when data enters the accounting system. Use validation rules to ensure data integrity and consistency, such as ensuring positive transaction amounts, valid dates, and existing account references. This layered validation minimizes the risk of dirty data entering the system, which can lead to inaccurate reports.
  3. Build a Complete and Tamper-Proof Audit Trail: Every journal entry, every change to a transaction, and every access to the system must be recorded in detail. The audit trail must include who performed the action, when, and what changes occurred. This is crucial for audit compliance, error tracing, and ensuring accountability, in accordance with good accounting principles.
  4. Prioritize Financial Data Security: Financial data is highly sensitive. Ensure the implementation includes data encryption in transit (SSL/TLS) and at rest, strict role-based access control (RBAC), and strong password policies. Conduct regular security audits to identify and address potential vulnerabilities, and ensure compliance with applicable data privacy regulations.
  5. Perform Thorough Testing (Unit, Integration, UAT): Never skip the testing phase. Perform unit testing for each code component, integration testing to ensure modules work together, and most importantly, User Acceptance Testing (UAT) with the accounting team. This UAT must include verification of the generated financial statements against manual reports or the old system to ensure accuracy and PSAK compliance.
  6. Design the System for Scalability and Flexibility: Consider data growth and potential changes in business needs in the future. Use a modular architecture that allows the addition of new features or adjustments to accounting rules without overhauling the entire system. A robust PostgreSQL database and a framework such as Django already provide a good foundation for scalability.
  7. Complete and Clear Documentation: Document all aspects of the system, from architecture, ERD (Entity Relationship Diagram), data process flows, API definitions, to user guides for end-users. Good documentation is a valuable asset for system maintenance, onboarding new teams, and troubleshooting in the future.
  8. Plan a Backup and Disaster Recovery Strategy: Ensure there is a scheduled and regularly tested data backup strategy, as well as a comprehensive Disaster Recovery Plan. This will protect your financial data from loss due to hardware failure, cyber attacks, or natural disasters, ensuring business operational continuity.

FAQ about PSAK Financial Report Automation

1. Can this financial report automation system be integrated with an existing Hospital Management Information System (SIMRS) or Clinic Information System (SIM Klinik)?
Yes, it is very possible and highly recommended. Integration is usually done through an API (Application Programming Interface) provided by the SIMRS/SIM Klinik, or by building a custom database connector if an API is not available. This process requires mapping transaction data from the SIMRS/SIM Klinik (for example, registration data, medical procedures, drug prescriptions, payments) into the appropriate accounting journal structure. We can help design the most effective integration strategy according to your current system capabilities, whether through a RESTful API, file exchange, or message queue mechanism.

2. What if there are changes to PSAK standards in the future? Will this system be difficult to adapt?
A well-designed system will have a modular architecture and parameterization of accounting rules. This means that business logic related to PSAK (for example, depreciation methods, revenue recognition) can be configured through parameters or separate modules, rather than being hardcoded in the code. Thus, when there is a change in PSAK (for example, PSAK 73 on Leases), adjustments can be made relatively easily through configuration or updates to specific modules without having to overhaul the entire system. This flexibility is key to the long-term sustainability of the system.

3. How long does it take to implement this PSAK financial report automation system at our healthcare facility?
Implementation time varies greatly depending on the complexity of your healthcare facility, transaction volume, the condition of the existing SIMRS/SIM Klinik, and the desired features. For a Minimum Viable Product (MVP) covering core modules (general journal, general ledger, income statement, balance sheet) and basic integration, it usually takes 3 to 6 months. A more comprehensive project with advanced reporting features, deep integration with many systems, and other specific modules can take 9 months to more than a year. Careful planning and close collaboration between the IT and accounting teams are essential to accelerate this process.

4. Do we still need an accounting consultant if we are already using this automation system?
It is highly recommended to continue involving an accounting consultant, especially in the initial stages of design and implementation. They will be invaluable in helping define a Chart of Accounts (COA) that complies with PSAK, verifying the mapping of transactions to the correct accounts, and validating the financial reports generated by the system. Once the system is running stably, the consultant's role may diminish to an advisor for complex accounting issues or when there are regulatory changes. Accounting expertise remains vital to ensure compliance and accurate data interpretation.

5. What about the security of highly sensitive financial data in this automation system?
Data security is a top priority. The system will be designed with the highest security standards, including encryption of data in transit (for example, using HTTPS for APIs) and at rest (database encryption). Role-Based Access Control (RBAC) will be strictly implemented, ensuring that only authorized users can access certain data or functions. In addition, a comprehensive audit trail system will record every user activity. We will also ensure compliance with relevant data security standards and conduct regular penetration testing to identify and address potential vulnerabilities.

6. Is this system suitable for small clinics or healthcare facilities with limited budgets?
Yes, this system is designed with scalability and modularity in mind, making it suitable for healthcare facilities of various sizes. For small clinics or those with limited budgets, implementation can start with the most crucial core modules and gradually add other features as needs grow and budget becomes available. By using open-source technologies such as Python/Django and PostgreSQL, licensing costs can be minimized, making this solution more affordable than expensive enterprise accounting ERP systems. This phased approach allows for efficient investment and aligns with operational capacity.

The manual process of preparing financial reports in healthcare facilities is a source of significant inefficiency and risk. By adopting a PSAK-compliant automation system, you not only improve the accuracy and speed of reporting but also strengthen your organization's strategic position. Accurate and timely financial data enables better decision-making, solid regulatory compliance, and optimal resource allocation. Nugroho Setiawan and his team have a proven track record in developing hospital management information systems (SIMRS), Clinic MIS, BPJS/SatuSehat/FHIR integration, as well as various solid ERP and POS solutions. We understand the operational intricacies of healthcare facilities and their technical challenges. Don't let outdated accounting processes hinder your organization's progress. Contact us for a free consultation regarding your financial reporting automation needs. Nugroho Setiawan's team is ready to help design, develop, and implement the right solution, ensuring your business runs efficiently, transparently, and in accordance with applicable financial accounting standards.

Related solutions by PT Pilar Inovasi Informatika (Pilar Inovasi IT products): SIMRS (Hospital Information System) Clinic Management System BPJS & SatuSehat Integration. Need a free consultation?

Terakhir diperbarui 18 Oct 2026

Komentar

Komentar ditinjau sebelum tampil.

Belum ada komentar. Jadilah yang pertama!