DEV Community

Anthony Leignel
Anthony Leignel

Posted on Edited on

🧾 Self-Hosted PHP Billing System Architecture: From Signed Quotes to Payment Confirmation Without a Database

Self-hosted PHP billing system interface for payment confirmation and invoice tracking

A billing system involves more than generating PDF documents. It must also manage relationships between documents, preserve their history, control state transitions, and maintain the consistency of financial data.

When a signed quote becomes an invoice, and then a paid invoice after payment is received, each step must retain a connection to the previous operations.

These requirements are generally handled by an application connected to a database. An alternative approach is to build the system around structured files, metadata, and independent PHP components.

This article presents the architecture of a self-hosted web billing system covering the complete lifecycle of a service or sale of goods, from quote generation to revenue archiving, with Factur-X generation and secure engine updates.


1. A Self-Hosted Web Architecture

The system relies on PHP 8.1 or higher, a compatible web server, document generation libraries, and local data storage.

Unlike a fully client-side quote generator, this architecture includes a backend. It handles data persistence, document generation, authentication, and transitions between business states.

The public project structure can be represented as follows:

private/
β”‚
β”œβ”€β”€ web/
β”‚   β”œβ”€β”€ admin/
β”‚   β”œβ”€β”€ quote-entry.php
β”‚   β”œβ”€β”€ billing-entry.php
β”‚   β”œβ”€β”€ instant-bill.php
β”‚   β”œβ”€β”€ payment-proof.php
β”‚   β”œβ”€β”€ deposit-entry.php
β”‚   β”œβ”€β”€ expenses-entry.php
β”‚   β”œβ”€β”€ quote-space.php
β”‚   β”œβ”€β”€ billing-space.php
β”‚   β”œβ”€β”€ payment-check.php
β”‚   β”œβ”€β”€ expenses-check.php
β”‚   β”œβ”€β”€ payments.php
β”‚   β”œβ”€β”€ payments-close.php
β”‚   β”œβ”€β”€ approval.php
β”‚   β”œβ”€β”€ archive-export.php
β”‚   β”œβ”€β”€ revenue-export.php
β”‚   β”œβ”€β”€ expense-export.php
β”‚   β”œβ”€β”€ deposit-export.php
β”‚   β”œβ”€β”€ index.php
β”‚   β”œβ”€β”€ countries.php
β”‚   β”œβ”€β”€ client-search.php
β”‚   β”œβ”€β”€ secure-access.php
β”‚   β”œβ”€β”€ download-access.php
β”‚   β”œβ”€β”€ deposits.php
β”‚   β”œβ”€β”€ attachment.php
β”‚   β”œβ”€β”€ manifest.json
β”‚   └── archive-save.php
β”‚
β”œβ”€β”€ update-server/
β”œβ”€β”€ assets/
β”œβ”€β”€ dependencies/
β”œβ”€β”€ templates/
β”‚   └── document-layout.php
β”‚
β”œβ”€β”€ pa.php
β”œβ”€β”€ system-config.php
β”œβ”€β”€ auth.php
β”œβ”€β”€ facturx-builder.php
β”œβ”€β”€ facturx-injector.py
β”œβ”€β”€ mail-service.php
β”œβ”€β”€ document-engine.php
β”‚
β”œβ”€β”€ contracts/
β”œβ”€β”€ counters/
β”œβ”€β”€ logs/
β”‚
β”œβ”€β”€ data/
β”‚   β”œβ”€β”€ pending-bills/
β”‚   β”œβ”€β”€ staged-payments/
β”‚   β”œβ”€β”€ paid-bills/
β”‚   β”œβ”€β”€ temp-facturx/
β”‚   └── revenue-ledger/
β”‚
β”œβ”€β”€ updater/
β”œβ”€β”€ temp/
└── docs/
Enter fullscreen mode Exit fullscreen mode

This directory structure uses the names provided in the public documentation. The update-related directories will be detailed separately.

The main responsibilities are distributed across several components:

Component Responsibility
web/ Interfaces, forms, and entry points
document-engine.php Calculations, generation, and archiving
facturx-builder.php Factur-X XML construction
facturx-injector.py XML embedding into the PDF
auth.php User authentication
mail-service.php Document delivery and notifications
contracts/ Quote and signature archiving
counters/ Document numbering
data/ Invoices, payments, and financial journals
updater/ Engine update management

The document engine remains separate from the user interfaces. Different modules can therefore share the same generation rules without duplicating business logic.


2. Five Modules Connected Through a Single Document Lifecycle

The system includes five main modules:

  • Quote generation
  • Direct invoicing
  • Payment confirmation and tracking
  • Deposit tracking
  • Business expense management

These modules are not five independent applications. They use shared data and components.

The main lifecycle can be represented as follows:

Quote creation
       β”‚
       β–Ό
Quote archiving
       β”‚
       β–Ό
Review and signature
       β”‚
       β–Ό
Accepted quote
       β”‚
       β–Ό
Invoice generation
       β”‚
       β–Ό
Pending invoice
       β”‚
       β–Ό
Payment confirmation
       β”‚
       β”œβ”€β”€ Paid invoice
       β”œβ”€β”€ Revenue journal
       └── Archiving
Enter fullscreen mode Exit fullscreen mode

Deposits can occur before invoicing, while business expenses follow their own processing lifecycle.

The architectural challenge lies in preserving the relationships between these operations.

An invoice must be able to retrieve data from its associated quote. A payment must be linked to an identifiable invoice. A deposit must retain its connection to the original quote.

Without a database, these relationships are represented through references, metadata, and structured file organization.


3. From Quote to Electronic Signature

Quote generation begins with entering issuer information, client details, services or goods sold, amounts, and tax parameters.

The interface calculates totals in real time before document validation.

Once the quote is validated, the system stores the document and its metadata on the server. An individual token then allows the recipient to review and sign the quote online.

Quote form
       β”‚
       β–Ό
Data validation
       β”‚
       β–Ό
PDF generation
       β”‚
       β”œβ”€β”€ Document archiving
       β”œβ”€β”€ Metadata storage
       └── Token creation
                β”‚
                β–Ό
          Client email
                β”‚
                β–Ό
         Signature interface
Enter fullscreen mode Exit fullscreen mode

The approval.php entry point allows the recipient to review the document and provide a signature.

Signature capture relies on an HTML canvas compatible with mouse and touchscreen input.

Signature processing includes:

  • Validation of received data
  • Storage of the signature image
  • Metadata updates
  • Operation timestamping
  • Protection against duplicate signatures
  • Confirmation emails to both parties

The signature link is valid for 30 days.

A Document and a Business State Are Different Things

The presence of a PDF file is not sufficient to determine whether a quote has been accepted.

The system must also maintain a state that distinguishes a generated quote from a signed quote.

A conceptual representation could be:

{
    "quote_reference": "QUOTE-2026-0042",
    "status": "signed",
    "signed_at": "2026-06-12T14:30:00Z"
}
Enter fullscreen mode Exit fullscreen mode

This example illustrates the principle of storing a business state. It does not reproduce the system's internal metadata format.

The captured signature, timestamp, and associated document provide complementary traceability elements.

However, this architecture should not be confused with a qualified electronic signature service. A signature image and metadata alone are not sufficient to establish that level of assurance.


4. Reusing Data Without a Database

When creating an invoice, client and quote information often already exists in the archives.

Entering the same information again would introduce a risk of errors and discrepancies between documents.

The system uses a JSON endpoint, client-search.php, responsible for retrieving existing information using several search criteria:

  • SIREN or SIRET
  • VAT identification number
  • Email address
  • Client name
  • Quote number

The result allows forms to be prefilled and associated documents to be retrieved.

User search
       β”‚
       β–Ό
client-search.php
       β”‚
       β–Ό
Archive reading
       β”‚
       β–Ό
Normalization and search
       β”‚
       β–Ό
JSON response
       β”‚
       β–Ό
Form autofill
Enter fullscreen mode Exit fullscreen mode

This layer allows data to be reused without maintaining a client table in a SQL database.

A conceptual response could be:

{
    "client": {
        "name": "Example Company",
        "country": "FR",
        "type": "business"
    },
    "quotes": [
        {
            "reference": "QUOTE-2026-0042",
            "currency": "EUR",
            "status": "signed"
        }
    ]
}
Enter fullscreen mode Exit fullscreen mode

This model is intentionally simplified and does not represent the endpoint's actual response format.

Searching through archives introduces a trade-off. It avoids maintaining an additional database, but its cost can increase with the number of documents.

As the volume grows, this type of architecture may require derived indexes or optimized search mechanisms.


5. From Quote Reference to Factur-X Invoice

The billing engine can generate an invoice from an existing quote or from directly entered data.

When a quote is selected, the corresponding information is reused: client identity, service lines, amounts, tax parameters, and any applicable deposits.

The quote reference also serves as a control against duplicate invoicing.

Existing quote
       β”‚
       β–Ό
Data retrieval
       β”‚
       β–Ό
Business validation
       β”‚
       β”œβ”€β”€ Reference already invoiced?
       β”œβ”€β”€ Valid input data?
       └── Consistent amounts?
       β”‚
       β–Ό
Number assignment
       β”‚
       β–Ό
Invoice generation
Enter fullscreen mode Exit fullscreen mode

Annual invoice numbering relies on sequential counters protected against collisions.

In the European version of the system, document generation includes Factur-X.

The document combines a human-readable PDF/A-3 file with structured XML that can be processed by software.

The public components of this pipeline are:

document-engine.php
        β”‚
        β”œβ”€β”€ Calculations and business data
        β”‚
        β”œβ”€β”€ PDF generation with mPDF
        β”‚
        └── facturx-builder.php
                     β”‚
                     β–Ό
                Factur-X XML
                     β”‚
                     β–Ό
             facturx-injector.py
                     β”‚
                     β–Ό
              PDF/A-3 + XML
Enter fullscreen mode Exit fullscreen mode

Building both representations from the same business data helps maintain consistency.

The PDF presents information to the user, while the XML enables automated processing.

Generated documents also have a SHA-256 hash that can be used to verify their integrity.

A generic PHP example:

$hash = hash_file('sha256', $pdfPath);

if ($hash === false) {
    throw new RuntimeException(
        'Unable to calculate document hash'
    );
}
Enter fullscreen mode Exit fullscreen mode

The hash can be stored alongside the document metadata and later compared with the archived file's hash.

It allows content modifications to be detected, provided that the reference hash itself is protected. It does not constitute a digital signature of the document.


6. Pre-Generating a Paid Invoice Without Confirming Payment

One particular feature of the system is the preparation of two documents during invoicing:

  • The original invoice
  • A pre-generated paid version, kept in a pending state

The second version is not intended to be delivered to the client before payment has been confirmed.

The storage structure distinguishes these states:

data/
β”‚
β”œβ”€β”€ pending-bills/
β”‚   └── Invoices awaiting payment
β”‚
β”œβ”€β”€ staged-payments/
β”‚   └── Prepared paid versions
β”‚
β”œβ”€β”€ paid-bills/
β”‚   └── Archived paid invoices
β”‚
└── revenue-ledger/
    └── Revenue journal
Enter fullscreen mode Exit fullscreen mode

This separation distinguishes document preparation from validation of the corresponding financial event.

Invoice issued
       β”‚
       β”œβ”€β”€ Original invoice
       β”‚
       └── Prepared paid version
                    β”‚
                    β–Ό
             Awaiting payment
                    β”‚
                    β–Ό
             User confirmation
                    β”‚
                    β”œβ”€β”€ Archiving
                    β”œβ”€β”€ Document delivery
                    └── Revenue journal
Enter fullscreen mode Exit fullscreen mode

Pre-generation must not be interpreted as proof of payment. The document remains in an intermediate state until payment has been confirmed.

This distinction prevents an available technical artifact from being confused with a financial transaction that has actually occurred.


7. Payment Confirmation and Duplicate Prevention

The payment-check.php module displays invoices awaiting payment.

The user selects the relevant invoice, enters the payment date, and confirms the operation.

The system must then perform several related actions:

  1. Verify that the invoice has not already been marked as paid
  2. Update its state
  3. Archive the paid document
  4. Record the revenue in the CSV journal
  5. Send the document to the client

These actions represent a single business transition, even though they involve multiple separate write operations.

A simplified state representation:

PENDING
   β”‚
   β”‚ Payment confirmation
   β–Ό
PAID
   β”‚
   β”œβ”€β”€ Paid document archived
   β”œβ”€β”€ Revenue recorded
   └── Notification sent
Enter fullscreen mode Exit fullscreen mode

The system includes controls against duplicate form submissions, duplicate entries in the revenue journal, and write-locking mechanisms.

Without these protections, two concurrent requests could record the same payment twice.

An exclusive PHP lock can illustrate the principle:

$lock = fopen($lockPath, 'c');

if ($lock === false) {
    throw new RuntimeException('Lock unavailable');
}

if (!flock($lock, LOCK_EX)) {
    fclose($lock);
    throw new RuntimeException('Lock failed');
}

try {
    // Check whether the payment is already recorded.
    // Apply the transition if necessary.
    // Update the financial data.
} finally {
    flock($lock, LOCK_UN);
    fclose($lock);
}
Enter fullscreen mode Exit fullscreen mode

This example is educational. It does not reproduce the system's internal implementation.

A lock can control concurrent access, but it does not automatically make multiple writes to different files transactional.

If an interruption occurs after metadata has been updated but before revenue has been recorded, an inconsistency may remain.

A file-based financial architecture must therefore account for consistency checks and recovery mechanisms appropriate to these situations.


8. Deposit Management and Computed States

Deposits introduce an additional relationship between the quote, amounts received, and the final invoice.

The system allows multiple deposits to be recorded against the same quote. The amounts are accumulated and automatically retrieved during invoicing.

A conceptual example:

Quote amount      : €2,000

Deposit 1         :   €300
Deposit 2         :   €500

Total deposits    :   €800
Remaining balance : €1,200
Enter fullscreen mode Exit fullscreen mode

Deposit tracking relies on three states:

Not invoiced
      β”‚
      β–Ό
Awaiting payment
      β”‚
      β–Ό
Paid
Enter fullscreen mode Exit fullscreen mode

These states are computed from contract archives and pending or paid invoices.

The tracking module therefore does not need to maintain an independent state for every displayed entry. It uses existing data to determine the deposit's current status.

Results can be filtered by status and are paginated in groups of 20 entries.

Monthly Closing

A monthly closing operation allows deposits associated with paid invoices to be archived.

The process produces a CSV export, stores a JSON archive, and adds a marker to the contract metadata:

{
    "archived": true
}
Enter fullscreen mode Exit fullscreen mode

Closed entries are then removed from the active view.

This operation illustrates the difference between a dynamically computed state and a permanently recorded closing state.


9. Business Expense and Supporting Document Management

The system also includes a business expense tracking module.

This layer remains independent from client invoice generation while contributing to the consolidation of financial data.

It allows expenses to be recorded, supporting documents to be attached, and historical records to be viewed by month or year.

Supporting documents can be provided in several formats:

PDF
JPG
PNG
Enter fullscreen mode Exit fullscreen mode

The attachment.php component handles access to supporting documents, while expense-export.php produces the corresponding exports.

Separating revenue and expenses prevents financial events with different origins and processing rules from being mixed together.

The data can then be exported for use in an external accounting workflow.


10. International Tax Handling and Separation of Business Rules

The engine adapts documents according to several parameters: client location, client type, transaction type, and issuer tax status.

The European version supports both services and sales of goods.

The system distinguishes three tax zones:

fr     β†’ France
eu     β†’ European Union
world  β†’ Outside the European Union
Enter fullscreen mode Exit fullscreen mode

These zones are also represented in the revenue journal through the zone_tva field.

The country list is centralized in countries.php, with 249 entries and a distinction between the country name displayed in the interface and the ISO code used by the backend.

This normalization prevents different textual representations of a country from producing inconsistent behavior.

Selected country
        β”‚
        β–Ό
ISO normalization
        β”‚
        β–Ό
Tax zone
        β”‚
        β”œβ”€β”€ Client type
        β”œβ”€β”€ Transaction type
        └── Issuer tax status
                    β”‚
                    β–Ό
              Tax treatment
                    β”‚
                    β”œβ”€β”€ Tax calculation
                    └── Document notices
Enter fullscreen mode Exit fullscreen mode

The system also checks the format and consistency of intra-EU VAT identification numbers, including the country prefix and expected length.

These checks are performed both in the interface and on the server.

However, format validation does not constitute verification of the existence or actual tax validity of a VAT identification number.

Similarly, client location alone is not sufficient to determine the applicable tax treatment for every international transaction.

A Separate US Version

A version dedicated to the United States follows the same self-hosted billing system approach, but without Factur-X or European electronic invoicing requirements.

It supports services and sales of goods, with manual management of tax parameters.

This separation allows a common architectural foundation to be maintained without imposing European document requirements on a US installation.


11. Invoice Transmission and Accredited Platform Integration

Invoice generation and invoice transmission are separate responsibilities.

The European engine includes a pa.php connector responsible for handling transmission to the Accredited Platform (Plateforme Agréée, or PA) configured for the installation.

The documented routing distinguishes several situations:

Configuration Transmission
PA disabled Email delivery to the client
PA enabled, business client Transmission to the PA
PA enabled, individual client Email to the client and transmission to the PA

The connector remains independent of the document engine.

Generated invoice
       β”‚
       β–Ό
Transmission rules
       β”‚
       β”œβ”€β”€ Email
       β”‚
       └── PA connector
                 β”‚
                 β–Ό
          Accredited Platform
Enter fullscreen mode Exit fullscreen mode

This organization allows the Factur-X engine to evolve without replacing the integration specific to each installation.

The routing presented here describes the system's behavior. It does not mean that all B2C transmissions fall under the same regulatory framework as B2B electronic invoicing.

Regulatory transmission, e-reporting, and document delivery to the client must remain clearly identified responsibilities.

Self-hosting therefore does not mean the complete absence of external communications. The system retains its engine and data locally, but may communicate with email services, an Accredited Platform, or the update server.


12. File-Based Storage and Data Consistency

The entire system operates without a database.

Persistent data is distributed across several file types:

Data Format
Quotes PDF and metadata
Signatures PNG
Invoices PDF and metadata
Paid invoices PDF
Revenue journal CSV
Counters Integers
Deposit archives JSON and CSV
System logs Timestamped text

This organization allows documents to be accessed and archived without relying on a SQL server.

However, it requires the responsibilities of each file to be precisely defined.

A counter is mutable state. An archived invoice is a document intended to remain unchanged. A financial journal is a sequence of recorded events.

These types of data should not be handled in the same way.

Numbering and Concurrency

Sequential numbering relies on counters protected by locking mechanisms.

The principle is to prevent two processes from assigning the same number simultaneously.

Process A                Process B
    β”‚                        β”‚
    β–Ό                        β–Ό
Acquire lock               Wait
    β”‚                        β”‚
Read counter                 β”‚
    β”‚                        β”‚
Increment                    β”‚
    β”‚                        β”‚
Write counter                β”‚
    β”‚                        β”‚
Release lock                 β”‚
                             β–Ό
                        Acquire lock
Enter fullscreen mode Exit fullscreen mode

The protection must cover the entire read-modify-write operation, not just the final write.

It must also remain compatible with other business controls, including preventing duplicate invoicing from the same quote.

The absence of a database reduces certain infrastructure dependencies, but transfers responsibility for write consistency, backups, and recovery after interruptions to the application.


13. Authentication and Document Access

The system supports multiple users with individual credentials and independent sessions.

Documented mechanisms include:

  • Session protection
  • Session ID regeneration after authentication
  • Protection against brute-force attempts
  • Endpoint access control
  • Server-side data validation
  • Access tokens for sensitive documents

Documents intended for clients can be accessed through a token without directly exposing their physical storage location.

Document access link
         β”‚
         β–Ό
Token verification
         β”‚
         β”œβ”€β”€ Invalid β†’ Access denied
         β”‚
         └── Valid
               β”‚
               β–Ό
          Read document
               β”‚
               β–Ό
          HTTP PDF response
Enter fullscreen mode Exit fullscreen mode

The secure-access.php component represents this PDF access layer.

Possession of a valid link must not provide access to other documents or internal interfaces.

The separation between authenticated users and document recipients therefore represents an important architectural boundary.

The presence of these mechanisms does not, by itself, guarantee overall security. Their effectiveness depends on server configuration, access permission management, and implementation quality.


14. A Secure Engine Update System for Autonomous Installations

One of the challenges of self-hosted software is maintaining it after installation.

In the case of a Factur-X engine, document requirements and regulatory rules may evolve. Certain components must therefore be updated without replacing the entire application or altering existing financial data.

The system distinguishes two environments: the release publication server and the update module installed on the client's infrastructure.

The public structure of the update server is as follows:

update-server/
β”‚
β”œβ”€β”€ releases/
β”‚   β”œβ”€β”€ engine-release-1.0.0.zip
β”‚   β”œβ”€β”€ engine-release-1.0.0.sig
β”‚   β”œβ”€β”€ engine-release-1.0.1.zip
β”‚   └── engine-release-1.0.1.sig
β”‚
β”œβ”€β”€ api/
β”‚   └── version-endpoint.php
β”‚
β”œβ”€β”€ manifests/
β”‚   └── release-manifest.json
β”‚
β”œβ”€β”€ private/
β”‚   β”œβ”€β”€ server-config.php
β”‚   β”œβ”€β”€ signing-private.key
β”‚   └── signing-public.key
β”‚
β”œβ”€β”€ source/
β”‚   └── engine-source/
β”‚       β”œβ”€β”€ xml-handler.py
β”‚       β”œβ”€β”€ invoice.php
β”‚       β”œβ”€β”€ engine-module.py
β”‚       └── document-generator.php
β”‚
└── tools/
    β”œβ”€β”€ release-builder.php
    └── release-signer.php
Enter fullscreen mode Exit fullscreen mode

Versions are distributed as archives accompanied by a cryptographic signature.

On the client installation side:

updater/
β”‚
β”œβ”€β”€ update-check-module.php
β”œβ”€β”€ update-deployment-module.php
β”œβ”€β”€ update-alert-module.php
β”œβ”€β”€ version-cache.json
β”œβ”€β”€ verification.key
β”œβ”€β”€ installation-state.json
└── operations.log
Enter fullscreen mode Exit fullscreen mode

The publication server retains the components required to prepare and sign releases.

The client installation holds the public key required to verify them, without needing the private signing key.

Update Lifecycle

Version check
      β”‚
      β–Ό
New version available
      β”‚
      β–Ό
User notification
      β”‚
      β–Ό
Installation approval
      β”‚
      β–Ό
Release download
      β”‚
      β–Ό
Cryptographic verification
      β”‚
      β”œβ”€β”€ Invalid β†’ Abort
      β”‚
      └── Valid
            β”‚
            β–Ό
          Backup
            β”‚
            β–Ό
     Component replacement
            β”‚
            β–Ό
     Installed state update
Enter fullscreen mode Exit fullscreen mode

Installations check daily for the availability of a new version.

When an update becomes available, a notification appears in the interfaces. Installation remains subject to user approval.

The process downloads the relevant components, verifies the signature, creates a backup, and replaces the necessary files.

Local configurations, client documents, and financial data remain separate from the updated components.

This separation allows the engine to evolve without redeploying the entire system.

Release Signatures and Integrity

A cryptographic signature addresses a different requirement from a simple SHA-256 hash.

A hash allows file contents to be compared against a reference. A signature verified using a trusted public key also allows verification that the file was signed by the holder of the corresponding private key.

The update process must reject installation if verification fails.

The public documentation does not specify the signature algorithm used. However, the architectural principle relies on a clear separation between release creation and client-side verification.

A signed update does not automatically guarantee that its contents are free of defects. Backups, component validation, and interruption handling remain important parts of the process.


15. Exports and Financial Data Independence

The different modules produce exports that allow data to be used outside the application.

The system supports:

  • Monthly invoice exports as ZIP archives
  • Monthly or annual revenue exports as CSV
  • Monthly or annual expense exports as CSV
  • Monthly or annual deposit exports as CSV

The corresponding components are separated:

archive-export.php
revenue-export.php
expense-export.php
deposit-export.php
Enter fullscreen mode Exit fullscreen mode

This export layer must not become a second source of truth.

Exported files represent the data stored in the system's archives and journals. They can be used for backups, verification, or integration with external accounting workflows.

The objective is to preserve data that remains usable independently of the web interface.


Conclusion

Building a complete billing system without a database involves more than replacing SQL tables with JSON or CSV files.

It requires defining relationships between documents, managing state transitions, protecting concurrent writes, controlling numbering, and preserving traceability.

In this architecture, PHP handles business processing, web interfaces, and data persistence. Factur-X generation, signatures, payments, deposits, and expenses are organized around distinct components connected through explicit references and states.

The signed update mechanism adds another dimension: the ability to maintain an evolving document engine while preserving an autonomous installation and its local data.

This approach reduces dependence on centralized infrastructure, but requires particular attention to file consistency, access security, and recovery after interruptions.

The main challenge is therefore not removing a database. It is building a system whose responsibilities, states, and transitions remain understandable, controllable, and maintainable over time.


Technical Documentation

The GitHub repository presents the system's architecture, modules, and documentation. The production version and its source code are not publicly distributed.

View the technical documentation on GitHub


https://palks-studio.com

Top comments (2)

Collapse
 
17j profile image
Rahul Joshi •

Super insightful buildβ€”highlighting how freelancers need more than just invoicing tools but a complete financial system is spot on. This feels like a real step toward financial independence through tech πŸš€

Collapse
 
palks_studio profile image
Anthony Leignel •

Appreciate it.
Most issues I see aren’t about invoices themselves, but fragmented workflows.
The goal is to replace that with a single, structured system that runs on its own.