Hospital Operational Cost Optimization: A Practical Guide with SIMRS and FHIR

Modern hospital management faces dual pressures: improving service quality and sustainable cost efficiency. Data shows that the operational burden of hospitals in Indonesia, especially those related to pharmaceutical procurement, medical devices, and human resource payroll, can reach 70-80% of total revenue. This figure is often worsened by fragmented information systems, creating data silos that hinder visibility and strategic decision-making. Traditional SIMRS, although helpful, often fails to provide seamless interoperability between departments, causing duplication of work, manual errors, and detrimental inefficiencies. This is not only about reducing expenses, but also about how every rupiah spent can provide maximum impact for patient care and operational sustainability. This article will guide you through a practical approach to integrating SIMRS with the FHIR standard, a revolutionary solution for creating an integrated data ecosystem. We will discuss basic concepts, technical implementation details with real code examples, error handling case studies, best practices, and answer common questions, all aimed at helping your hospital achieve significant and sustainable operational efficiency.

Understanding Operational Cost Challenges and the Role of SIMRS-FHIR

Hospital operational cost challenges are very complex, covering various aspects from inventory management to human resource efficiency. One crucial area is pharmaceutical and medical device management, where overstocking or out-of-stock, drug expiration, and inefficient procurement practices often occur. Without accurate and real-time consumption data, hospitals struggle to predict needs, resulting in significant waste. In addition, manual or semi-automatic administrative processes, such as patient registration, scheduling, and insurance claims, take a lot of time and are prone to errors, which ultimately increases HR costs and the potential for claim rejections. Outdated or poorly integrated IT systems between departments (for example, electronic medical records separate from laboratory or radiology systems) create communication barriers and slow down clinical and administrative workflows.

Traditional SIMRS, although it has become the operational backbone, is often built as a monolithic system with limited integration between its modules. As a result, patient data may be inconsistent across departments, causing staff to repeatedly input the same information or manually search for data from various sources. This is not only inefficient, but also increases the risk of medical and administrative errors. For example, if patient allergy data in the registration system is not automatically connected to the pharmacy system, the risk of administering the wrong drug increases, potentially incurring much higher costs for handling medical complications.

This is where the role of FHIR-integrated SIMRS becomes crucial. FHIR (Fast Healthcare Interoperability Resources) is a health data exchange standard developed by HL7 International, designed to facilitate fast and easy data interoperability between different health systems. By adopting FHIR, patient data, prescriptions, laboratory results, and other clinical information can be standardized and exchanged in real-time between SIMRS modules (for example, from the registration module to the medical records, pharmacy, and billing modules) as well as with external systems such as the SatuSehat platform belonging to the Indonesian Ministry of Health, or BPJS Kesehatan. This means the same data can be accessed and updated by all authorized parties, eliminating duplication, reducing errors, and speeding up processes.

As a concrete example, a hospital that implements FHIR can reduce pharmacy inventory costs by up to 15% in a year. This is possible because prescription data (MedicationRequest FHIR Resource) from doctors is directly integrated with the pharmacy inventory system, enabling much more accurate prediction of drug needs. The system can automatically analyze consumption patterns, minimize overstocking of expensive drugs at risk of expiration, and ensure the availability of essential drugs. In addition, FHIR integration also speeds up the insurance claim process (Claim FHIR Resource) by providing complete and automatically validated data, reducing claim rejections that are often caused by data inconsistencies.

Technical Implementation Details: Modern SIMRS Architecture and FHIR Integration

The implementation of a modern SIMRS that adopts FHIR requires a flexible and scalable architectural approach. Although monolithic systems can still be integrated with FHIR through an API Gateway layer, the microservices approach is more recommended for the long term. A microservices architecture allows each SIMRS module (for example, registration, medical records, pharmacy, laboratory, radiology, billing) to operate as an independent service that communicates through APIs, facilitating development, maintenance, and scalability. This also makes integration with FHIR more modular, where each microservice can publish or consume relevant FHIR Resources.

For the technology stack, strong choices include: Backend using frameworks such as Laravel 11.x (PHP) or Node.js 20 LTS (JavaScript) with Express.js or NestJS. A reliable relational database such as PostgreSQL 16 is highly recommended due to its performance and advanced features. To manage FHIR data efficiently, you can use a dedicated FHIR server such as HAPI FHIR 6.8.0 (Java) or Aidbox (Clojure), which provides a RESTful API according to the FHIR R4 standard. Alternatively, you can develop a custom FHIR endpoint in your backend if the data volume and complexity are not too high. For asynchronous communication between microservices or with external systems, a message broker such as RabbitMQ or Apache Kafka is very useful, ensuring reliable and scalable message delivery.

Key points of FHIR integration in SIMRS include various key FHIR Resources. For example, when a patient registers, the patient data will be stored as a FHIR Patient Resource. When a doctor creates a prescription, that data becomes a FHIR MedicationRequest Resource. Laboratory results will be represented by a FHIR Observation Resource, and every patient interaction with the hospital will be recorded as a FHIR Encounter Resource. For insurance claims, the FHIR Claim Resource will contain all necessary information, including patient details, services provided, and costs. The standard used is FHIR R4, which is the stable and most widely adopted version, especially for integration with the SatuSehat platform of the Indonesian Ministry of Health (Kemenkes RI).

The integration process can be illustrated as follows: When a new patient registers, the SIMRS system will create or update a FHIR Patient Resource and send it to the central FHIR server. This FHIR patient ID is then used throughout the system. When a doctor prescribes medication, a FHIR MedicationRequest Resource will be created, referring to the relevant Patient ID and Encounter ID. This resource can be accessed by the pharmacy module for dispensing and the billing module for cost calculation. Similarly, the results of supporting examinations such as laboratory or radiology will be uploaded as a FHIR Observation Resource, which can then be accessed by doctors through an FHIR-based electronic medical record. This integration ensures that all relevant data is available in real-time at the right point of care, reducing the need for manual input, minimizing errors, and significantly accelerating clinical and administrative workflows.

Example of FHIR Implementation Code for Data Efficiency

The implementation of FHIR in SIMRS is not only theoretical but also practical with the support of various libraries and SDKs. The following is a simple implementation example using PHP (Laravel) to interact with a FHIR server, which can serve as a basis for building more complex integrations. The first example shows how to create a FHIR Patient Resource, and the second example shows how to retrieve a FHIR MedicationRequest Resource for pharmacy stock management purposes.

Code Block 1: Sending Patient Data to FHIR Server (PHP - Laravel)

<?phpnamespace Apphir;use GuzzleHttpClient;use GuzzleHttpExceptionRequestException;class FhirClient{
    protected $client;
    protected $fhirBaseUrl;
    public function __construct()
    {
        $this->fhirBaseUrl = env('FHIR_SERVER_BASE_URL', 'http://localhost:8080/fhir');
        $this->client = new Client(['base_uri' => $this->fhirBaseUrl]);
    }
    public function createPatient(array $patientData): ?array
    {
        $resource = [
            'resourceType' => 'Patient',
            'id' => uniqid(), // Atau gunakan ID dari SIMRS Anda
            'name' => [
                [
                    'use' => 'official',
                    'family' => $patientData['lastName'],
                    'given' => [$patientData['firstName']],
                ]
            ],
            'gender' => $patientData['gender'],
            'birthDate' => $patientData['birthDate'],
            'telecom' => [
                [
                    'system' => 'phone',
                    'value' => $patientData['phone'],
                    'use' => 'mobile'
                ]
            ],
            'address' => [
                [
                    'use' => 'home',
                    'text' => $patientData['address']
                ]
            ]
        ];
        try {
            $response = $this->client->post('Patient', [
                'json' => $resource,
                'headers' => [
                    'Content-Type' => 'application/fhir+json'
                ]
            ]);
            return json_decode($response->getBody()->getContents(), true);
        } catch (RequestException $e) {
            // Log error atau tangani sesuai kebijakan
            error_log('Error creating Patient: ' . $e->getMessage());
            if ($e->hasResponse()) {
                error_log($e->getResponse()->getBody()->getContents());
            }
            return null;
        }
    }
}}// Contoh penggunaan di Controller atau Service$fhirClient = new FhirClient();$newPatient = [
    'firstName' => 'Budi',
    'lastName' => 'Santoso',
    'gender' => 'male',
    'birthDate' => '1990-05-15',
    'phone' => '081234567890',
    'address' => 'Jl. Merdeka No. 1, Jakarta'
];
$result = $fhirClient->createPatient($newPatient);
if ($result) {
    echo 'Patient created with FHIR ID: ' . $result['id'];
} else {
    echo 'Failed to create patient.';
}

Explanation of Code Block 1: This code uses the Guzzle HTTP Client library to send a POST request to the FHIR server. Patient data from the local SIMRS is converted into a standard FHIR Patient Resource structure. By automating this process, hospitals can ensure that every new patient registration is instantly available in a format accessible by other FHIR-compatible systems, reducing manual input and potential errors, and accelerating the registration and data verification workflow. The unique ID generated or used from the local SIMRS will serve as the patient's global reference.

Code Block 2: Retrieving Prescription Data (MedicationRequest) from FHIR Server (PHP - Laravel)

<?phpnamespace App\fhir;use GuzzleHttp\Client;use GuzzleHttp\Exception\RequestException;class FhirClient{    protected $client;    protected $fhirBaseUrl;    public function __construct()    {        $this->fhirBaseUrl = env('FHIR_SERVER_BASE_URL', 'http://localhost:8080/fhir');        $this->client = new Client(['base_uri' => $this->fhirBaseUrl]);    }    public function getMedicationRequestsByPatient(string $patientFhirId): array    {        try {            $response = $this->client->get('MedicationRequest', [                'query' => [                    'patient' => $patientFhirId,                    '_count' => 10 // Ambil 10 resep terbaru                ],                'headers' => [                    'Accept' => 'application/fhir+json'                ]            ]);            $bundle = json_decode($response->getBody()->getContents(), true);            $medicationRequests = [];            if (isset($bundle['entry'])) {                foreach ($bundle['entry'] as $entry) {                    $medicationRequests[] = $entry['resource'];                }            }            return $medicationRequests;        } catch (RequestException $e) {            error_log('Error fetching MedicationRequests: ' . $e->getMessage());            if ($e->hasResponse()) {                error_log($e->getResponse()->getBody()->getContents());            }            return [];        }    }}// Contoh penggunaan di Controller atau Service$fhirClient = new FhirClient();$patientId = 'fhir-patient-id-from-previous-creation'; // ID FHIR pasien yang sudah ada$medicationRequests = $fhirClient->getMedicationRequestsByPatient($patientId);if (!empty($medicationRequests)) {    echo 'Medication Requests for Patient ' . $patientId . ':<br>';    foreach ($medicationRequests as $request) {        $medicationName = $request['medicationCodeableConcept']['text'] ?? 'Unknown Medication';        echo '  - ' . $medicationName . ' (Status: ' . $request['status'] . ')<br>';    }} else {    echo 'No medication requests found for patient ' . $patientId;}

Explanation of Code Block 2: This code retrieves a list of prescriptions (MedicationRequest) for a specific patient from the FHIR server. This data is very valuable for the pharmacy module. By accessing prescription data centrally and in real-time, the inventory management system can automatically update stock, trigger reorders when stock runs low, and even identify drug consumption patterns for future procurement optimization. This directly contributes to reducing inventory costs by minimizing overstock, preventing expiration, and ensuring the right drugs are available at the right time. The use of an FHIR SDK or HTTP client library such as Guzzle simplifies interaction with the FHIR REST API, freeing developers from protocol details and allowing them to focus on business logic.

Case Study: BPJS Claim Optimization with FHIR Payload and Error Handling

One of the areas with the greatest potential for cost savings in hospitals is the insurance claim process, particularly BPJS Kesehatan. Rejected or delayed claims are often caused by incomplete, inconsistent, or non-standard data. By adopting FHIR, hospitals can significantly improve the accuracy and speed of the claim process, reducing administrative burden and accelerating cash flow. The SatuSehat platform of Kemenkes RI, which is based on FHIR R4, is a real example of how this standard facilitates claim integration.

The following is an example of a realistic FHIR Claim Resource payload, which can be used to send claim data to an external system or within the SIMRS for validation:

{
  "resourceType": "Claim",
  "status": "active",
  "type": { "coding": [{ "system": "http://terminology.hl7.org/CodeSystem/claim-type", "code": "institutional" }] },
  "use": "claim",
  "patient": { "reference": "Patient/12345" },
  "created": "2024-05-20",
  "provider": { "reference": "Organization/RS-001" },
  "priority": { "coding": [{ "code": "normal" }] },
  "insurance": [{ "sequence": 1, "focal": true, "coverage": { "reference": "Coverage/BPJS-98765" } }],
  "item": [{
    "sequence": 1,
    "productOrService": { "coding": [{ "system": "http://hl7.org/fhir/sid/icd-9-cm", "code": "99.15" }] },
    "net": { "value": 1500000, "currency": "IDR" }
  }],
  "total": { "value": 1500000, "currency": "IDR" }
}

The above payload must be validated against the applicable FHIR profile (for example, the Claim profile from SatuSehat) before being sent. Good error handling includes checking the OperationOutcome in the server response, structured logging, and a retry mechanism with exponential backoff for temporary failures. This way, problematic claims can be corrected immediately without waiting for a lengthy manual process.

Practical Tips for FHIR-Based SIMRS Implementation

Start from a small but high-impact scope, such as pharmacy modules or patient registration. Map existing data flows, identify integration points with FHIR, then build an adapter layer that translates internal data models to FHIR resources. This gradual approach reduces the risk of operational disruption and facilitates ROI evaluation at each stage.

Invest in data quality from the start. FHIR relies heavily on consistent references (for example Patient.id, Encounter.id). Create a clean master patient index policy, validate input on the client side, and implement standard terminology such as ICD-10, LOINC, and SNOMED CT. Clean data will cut debugging time and prevent claim rejections.

Finally, prepare monitoring and audit trail. Use an API gateway to record every FHIR transaction, monitor latency, error rates, and request volume. With this visibility, IT teams and management can make data-driven decisions, for example allocating resources to modules that fail most often or contribute most to cost savings.

FAQ

Does the existing SIMRS have to be completely replaced to support FHIR?

No. You can add middleware or a facade service that bridges the old database with the FHIR API. This approach is more cost-effective and minimizes service disruption.

How does FHIR help reduce rejected BPJS claims?

FHIR ensures claim data structures comply with standards, so validation can be performed automatically before submission. This reduces human error and speeds up the verification process.

Is FHIR implementation expensive?

Initial costs depend on scale. However, many open source libraries (HAPI FHIR, fhir.js) and cloud services reduce costs. Savings from operational efficiency are usually felt within 6–12 months.

Is patient data safe with FHIR?

FHIR supports security standards such as OAuth2, SMART on FHIR, and TLS encryption. The key is to implement role-based access control and strict audit logs.

Optimizing hospital operational costs is no longer just about budget cuts, but measurable digital transformation. By leveraging a SIMRS integrated with FHIR, hospitals can improve data accuracy, speed up claims, control inventory, and ultimately provide better services at more efficient costs. Don't let fragmented systems erode your margins and service quality. Consult your hospital's SIMRS and FHIR integration needs with our expert team now to get a practical, secure, and regulation-compliant roadmap.

This article is part of the education by Nugroho Setiawan, an IT consultant in Jogja. Related solutions: SIMRS BPJS & SatuSehat Bridging Integrator. Need free consultation?