Relevant experience

Behind every challenge, a decision.

Three narratives to explore the founding team’s technical reasoning: what is at stake, which decisions were made and how to bound the next step.

Banking and payments

Founding-team experience · through third parties

Asynchronous payments with integrations that need immediate responses

Process a high volume of payments by combining asynchronous microservices with synchronous third-party APIs.

Period
Not specified
Role
Payment development and integration

Context and constraints

Participation in euro-payment development for payments originating in the UK in the context of Brexit, a bank’s Bizum implementation and integration with fintechs in the same group.

The flow needed to absorb a high volume of information while working with external APIs that required synchronous communication.

Scope: Development and integration as part of a team; creation of the entire service is not attributed to one person.

Friction and risk

An asynchronous architecture alone could not handle every exchange: some steps depended on third-party responses.

Decision and trade-offs

Implemented decisions as described by the content owner; the comparison explains their roles and trade-offs.

The team chose an asynchronous architecture with Kafka and Spring Boot microservices. Synchronous communication was retained where third-party APIs required it.

View complementary decisions
  • Kafka and asynchronous microservices

    The chosen foundation for absorbing information volume and organising processing.

  • Synchronous third-party integrations

    Required at specific steps; the flow had to accommodate their response conditions.

Process and intervention

Process payment information through Kafka → Implement business logic in Spring Boot microservices → Integrate external APIs and refine each step of the flow.

View the journey step by step
  1. Process payment information through Kafka
  2. Implement business logic in Spring Boot microservices
  3. Integrate external APIs and refine each step of the flow

Learning

The intended objective was achieved through successive adjustments. The lesson was to combine asynchronous processing with actual synchronous dependencies, rather than impose a single pattern on every integration.

Narrative basis: First-hand account by Raúl Plaza, a participant and the content owner. Qualitative outcomes, without audited metrics.

Next step

Explore the related service

Healthcare information

Founding-team experience · through third parties

A healthcare information hub that evolves through modules

Bring clinical and care information together and make it available to other applications without freezing the architecture.

Period
Not specified
Role
Technology leadership and architecture design

Context and constraints

Design of a medical information hub bringing together appointments, diagnoses, care encounters and information about patients and healthcare professionals.

The system needed to absorb millions of data items each day and provide access to external applications. This volume describes the project requirement, not an audited performance measurement.

Scope: Technology leadership and architecture design, including an API to access stored information.

Friction and risk

Requirements kept evolving: the platform needed to accommodate changes without being constrained by its initial design.

Decision and trade-offs

Implemented decisions as described by the content owner; the comparison explains their roles and trade-offs.

Microservices with asynchronous communication were chosen for ingestion, alongside an API for third-party applications that needed to query the information.

View complementary decisions
  • Microservices and asynchronous communication

    The chosen structure for absorbing information and enabling modular platform evolution.

  • API for external applications

    A defined way to access stored information, complementing internal processing.

Process and intervention

Bring in clinical and care information → Process it through asynchronously communicating microservices → Provide API access and evolve the modules.

View the journey step by step
  1. Bring in clinical and care information
  2. Process it through asynchronously communicating microservices
  3. Provide API access and evolve the modules

Learning

The platform is operational and its architecture has evolved with project needs. Modularity has enabled changes from the initial design. The lesson is to treat architecture as a structure that evolves with use.

Narrative basis: First-hand account by Raúl Plaza, a participant and the content owner. Qualitative outcomes, without audited metrics.

Next step

Explore the related service

Metering and IoT

Founding-team experience · through third parties

Meter-data ingestion at the providers’ pace

Integrate electricity and water readings from IoT providers into an architecture designed for large data volumes.

Period
Not specified
Role
Product refactoring and microservice design

Context and constraints

Refactoring parts of a metering product and designing a microservice architecture to channel data from external providers.

Providers sent readings at their own pace; the platform needed to adjust its ingestion capacity to that traffic.

Scope: MQTT integration with external IoT providers and routing electricity and water readings through microservices and Kafka.

Friction and risk

Receiving large volumes of readings required coordinating incoming integrations with internal processing.

Decision and trade-offs

Implemented decisions as described by the content owner; the comparison explains their roles and trade-offs.

The team implemented MQTT to integrate providers and a new microservice architecture with Kafka to channel meter-reading traffic.

View complementary decisions
  • MQTT for provider integration

    Enabled the intake of readings from external IoT providers.

  • Kafka and microservices for ingestion

    Channelled traffic through the new architecture; processing pace needed to match provider submissions.

Process and intervention

Receive electricity and water readings through MQTT → Channel traffic through Kafka and microservices → Adjust ingestion to the providers’ sending rate.

View the journey step by step
  1. Receive electricity and water readings through MQTT
  2. Channel traffic through Kafka and microservices
  3. Adjust ingestion to the providers’ sending rate

Learning

An operational application serving large population centres was achieved. The lesson was to adapt the platform’s ingestion speed to the providers’ sending rate to sustain a good processing pace.

Narrative basis: First-hand account by Raúl Plaza, a participant and the content owner. Qualitative outcomes, without audited metrics.

Next step

Explore the related service

Relevant experience

Facing a similar challenge?

Let’s review your constraints and the first step worth validating.