All case studies
Anonymous · 20269 min read

From Client Problem to Integration

How I brought client needs, business requirements and technical implementation together in one application.

Project preview
From Client Problem to Integration

License data and Azure resources were available. The challenge was to reliably assign them to the right clients and structures in HALO.

For HALO connect, I was responsible for the entire project: from understanding the client's problems and structuring and prioritizing requirements to technical implementation. The client described their workflows and the difficulties involved in transferring data. Based on this, I defined the application's purpose and scope.

The result is a web application that processes license data from different CSV formats, discovers Azure resources and transfers information to HALO. The key decisions lay in the business rules: Which data belongs together? How are existing records identified? Which mappings do users need to configure themselves? And what feedback do they need after a transfer?

Project overview

Application

HALO connect, an integration application for HALO PSA

My responsibilities

Client communication, requirements clarification, prioritization and technical implementation

Focus

License imports, Azure inventory and assignment to the correct client context

Technology

Next.js, React, TypeScript, FastAPI, PostgreSQL and Azure services

License imports

Azure integration

Data transfers

Three supported CSV formats

Configurable mappings for resource types and fields

Separate results for created, updated, skipped and failed assets

Bringing data from multiple sources into HALO

The project focused on importing information from different systems. CSV files contained license and usage data. Azure provided clients, subscriptions and resources. In HALO, this information had to fit into existing client, license and asset structures.

Each transfer required several decisions. A file had to be read, a client reference resolved and an existing record identified. Azure added different resource types, each with its own properties.

My starting point was therefore the complete workflow: How can external license and infrastructure information be transferred into existing HALO structures in a way users can verify? This led to requirements for data validation, mapping, updates and result reporting.

Turning client problems into specific requirements

I broke the task down into questions that had to be answered before implementation:

  • Which data sources and export formats should the application support?
  • What information does HALO need to import the data correctly?
  • Which references can identify clients and existing records?
  • What rules are required for each source?
  • Which settings do users need to maintain themselves?
  • How should missing prerequisites and errors be handled?

I brought the client's expectations together with the conditions required for implementation. The client needed a clear workflow. Development required explicit rules for data formats, identifiers and exceptions.

Because I also handled implementation, I could directly assess the consequences of these decisions. A missing client reference affects assignment, for example. A missing subscription ID changes how existing licenses are identified. These details determine how far a workflow can be automated and where users need feedback.

Each format needs its own rules

HALO connect supports CSV files for Mailarchiv, STARFACE and ADN. The formats differ both in their columns and in the meaning of their values. Each source therefore has its own processing logic.

For users, the goal was a repeatable workflow: select an export, upload the file and transfer the data to HALO according to the defined rules.

Processing accounts for file type, expected columns, delimiters, quantities, dates and prices. For Mailarchiv, license quantities within the specified grouping are consolidated using their maximum value. For ADN, processing includes positive quantities, end-customer references and external subscription IDs.

These differences shaped the import requirements. An upload can succeed technically while producing an incorrect business result. Alongside the file format, the interpretation and consolidation of values therefore had to be defined.

Reliable references as a prerequisite

An Azure resource belongs to a subscription, which in turn belongs to a tenant. For a transfer, this relationship must resolve to the appropriate client or site in HALO.

The application supports different sources for Azure tenant IDs: the Azure/CSP integration in HALO, a configured custom field or automatic selection with a fallback. This allows assignment to adapt to existing data structures.

The central rule is: Data is assigned using reliable references. A similar display name is insufficient. Resolving these identifiers is a prerequisite for the next steps, because even a correctly structured asset would be unusable in the wrong client context.

Making business rules configurable

Azure describes resources through technical types and properties. HALO uses asset types with their own fields. HALO connect links these structures through two mappings:

Mapping

Purpose

Service mapping

Links an Azure resource type to a HALO asset type

Field mapping

Defines which Azure property is written to which HALO field

Users can maintain these mappings themselves. Changes to the HALO structure do not require a code change for every individual adjustment. Available Azure fields are identified from stored resource structures; the backend also supports schema templates.

Configurable mappings account for the different information required by different resource types. A fixed field list would have limited the integration's scope early on.

Identifying and updating existing data

License inventories and Azure resources change over time. Imports therefore need to remain predictable when run again.

Assets are identified through a primary value and a comparison with existing HALO assets. A matching record is updated; otherwise, a new one is created. License processing also checks for existing entries.

The appropriate identifier depends on the source. For ADN entries without an external subscription ID, the current processing logic creates a new record. This exception matters because it determines what users can expect from repeated imports. The application can reliably identify existing entries only when the required references are available.

Enabling the next step

After a transfer, users need to see what was imported and where follow-up work is required.

For CSV imports, the application stores information including a label, file metadata, timestamps, processing status and results. For asset transfers covering an entire client, the backend returns separate results for created, updated, skipped and failed resources.

A skipped record may indicate a missing mapping, for example. With this information, the user can add the mapping and trigger the transfer again. Result reporting is therefore part of the complete workflow and shapes the requirements for both the interface and processing logic.

Defining scope and priorities through dependencies

The features depend on one another. Azure resources can only be transferred meaningfully once the client has been identified, the resource type mapped and the fields configured. A CSV import needs a suitable file and a working HALO connection.

The complete workflow therefore guided how I structured the work. Selection, validation, processing, transfer and feedback must work together to produce a usable result.

The following areas show the application's functional dependencies:

Area

Contribution to the workflow

Authentication and connections

Enable access to the application and the intended HALO destination

CSV processing

Validate and process supported files and store results

Azure data collection

Discover clients, subscriptions and resources

Client and field mapping

Assign data to the appropriate HALO structures

Identification of existing assets

Support repeated transfers and updates

Search and pagination

Keep larger datasets manageable

The scope remained focused on defined license formats and a specific Azure-to-HALO workflow. This gave development clear boundaries and made individual use cases verifiable. The table describes these dependencies rather than a delivery sequence reconstructed after the fact.

Handling prerequisites and errors visibly

The application connects several systems. HALO must be reachable, credentials must work, CSV files must match the selected format and client references must be available.

I treated these prerequisites as part of the workflow. They lead to specific checks and feedback: Is a connection missing? Is a field mapping available for the resource type? Is there a primary value that can identify the asset?

An individual asset transfer checks these conditions, among others. When transferring an entire client inventory, resources without the necessary prerequisites are skipped. Errors for individual resources are collected while processing can continue for other resources.

Selecting the destination system is also part of these requirements. HALO connect manages multiple named HALO connections with environment labels and status information. Authentication uses Microsoft Entra ID, and Azure Key Vault is integrated for credentials. Whether a transfer reaches the correct destination still depends on the connection being configured and selected correctly.

Making expected behavior verifiable

Business requirements can be checked against specific use cases. The existing implementation supports criteria such as the following:

Use case

Expected behavior

Upload a supported CSV file

Required columns are checked; an invalid format produces clear feedback.

Transfer a new asset

An asset is created when the client assignment and mappings are valid and the primary value is not yet known.

Transfer an existing asset again

A valid asset identified through its primary value is updated.

Transfer an individual asset without a primary value

The transfer is rejected with an error message.

Transfer a client inventory with a missing mapping

Affected resources are skipped and included in the results.

An error occurs for a resource

The results include information about the affected resource.

Discover the Azure inventory again

Another scan can be run; a timestamp for the resource scan is retained.

These criteria connect client expectations with behavior that can be verified. They also help define scope: Which cases must the workflow cover? Which exceptions need their own handling? What information does the user need afterward?

Aligning technical decisions with the workflow

The frontend uses Next.js, React and TypeScript. The backend uses Python with FastAPI. PostgreSQL stores information including clients, resources, mappings and import operations. Docker Compose and Traefik are intended for deployment.

This structure supports the workflow: the interface guides selection and configuration, the backend processes the data, and stored mappings and results remain available for subsequent operations.

One improvement concerned CSV processing. It was moved from an earlier n8n webhook flow to direct processing in the backend. The current upload route uses this approach; older webhook methods remain as legacy code.

Processing and result handling now sit within the application and can be developed together. Claims about lower operating costs or higher speed would require additional measurements.

The visible development history from February to August 2026 also includes changes to connections, authentication, CSV headers, mappings, search, pagination, Azure transfers and deployment. This work shows how the scope extended beyond data transfer to usability and operational prerequisites.

Results and further development

HALO connect brings several integration tasks together in one application. Users can import three supported CSV formats, discover Azure clients and resources, maintain mappings and trigger transfers as needed.

Existing assets are identified through a primary value. Results distinguish between creation, updates, skipped resources and errors. This makes completed steps and remaining work visible.

The project illustrates how I approach open-ended client requirements: I clarify the required workflow, translate it into business rules, organize dependencies and implement an application around them. Client communication, scope decisions and development remain closely connected.

For further development, actual usage data would provide the next benchmark: processing time per import, the proportion of correctly assigned resources, reasons for skipped records and the effort required for follow-up work. These measures would help prioritize improvements based on their impact on everyday work.

The client remains anonymous. This account draws on the problems described, the existing implementation and the visible development history. Requirements and verification criteria are derived from these sources; they do not represent original requirements or acceptance documentation. The described functionality is supported by the available evidence. This alone does not establish a production rollout, time savings or a reduction in errors.