Hi! I'm

Federico Calò

Software Developer | Technical Writer

I create modern web applications and custom digital tools to help businesses grow through technological innovation. My passion is combining computer science and economics to generate real value.

Contact Me

About Me

My passion for computer science was born at the Technical Commercial Institute of Maglie, where I discovered the power of programming and the fascination of creating digital solutions. From the start, I understood that computer science was not just code, but an extraordinary tool for turning ideas into reality.

During my studies in Business Information Systems, I began to interweave computer science and economics, understanding how technology can be the engine of growth for any business. This vision accompanied me to the University of Bari, where I obtained my degree in Computer Science, deepening my technical skills and passion for software development.

Today I put this experience at the service of businesses, professionals and startups, creating tailor-made digital solutions that automate processes, optimize resources and open new business opportunities. Because true innovation begins when technology meets the real needs of people.

My Skills

Data Analysis & Predictive Models

I transform data into strategic insights with in-depth analysis and predictive models for informed decisions

Process Automation

I create custom tools that automate repetitive operations and free up time for value-added activities

Custom Systems

I develop tailor-made software systems, from platform integrations to customized dashboards

const federico = {
  nome: "Federico Calò",
  ruolo: "Sviluppatore Software",
  città: "Bari, Italia",
  missione: "Aiutare attraverso l'informatica",
  passioni: [
    "Codice Pulito",
    "Innovazione",
    "Crescita Continua"
  ]
};

La Mia Missione

Credo fermamente che l'informatica sia lo strumento più potente per trasformare le idee in realtà e migliorare la vita delle persone.

🚀

Democratizzare la Tecnologia

La mia missione è rendere l'informatica accessibile a tutti: dalle piccole imprese locali alle startup innovative, fino ai professionisti che vogliono digitalizzare la propria attività. Ogni realtà merita di sfruttare le potenzialità del digitale.

💡

Unire Informatica ed Economia

Non è solo questione di scrivere codice: è capire come la tecnologia possa generare valore reale. Intrecciando competenze informatiche e visione economica, aiuto le attività a crescere, ottimizzare processi e raggiungere nuovi traguardi di efficienza e redditività.

🎯

Creare Soluzioni su Misura

Ogni attività è unica, e così devono esserlo le soluzioni. Sviluppo strumenti personalizzati che rispondono alle esigenze specifiche di ciascun cliente, automatizzando processi ripetitivi e liberando tempo per ciò che conta davvero: far crescere il business.

Trasforma la Tua Attività con la Tecnologia

December 2024

View

Master SQL

RoadMap.sh

Novembre 2024

View

Oracle Certified Foundations Associate

Oracle

October 2024

View

People Leadership Credential

Connect

Settembre 2024

💻 Languages & Technologies

☕Java

🐍Python

📜JavaScript

🅰️Angular

⚛️React

🔷TypeScript

🗄️SQL

🐘PHP

🎨CSS/SCSS

🔧Node.js

🐳Docker

🌿Git

💼

12/2024 - Presente

Custom Software Engineering Analyst

Accenture

Bari, Puglia, Italia · Ibrida Analisi e sviluppo di sistemi informatici attraverso l'utilizzo di Java e Quarkus in Health and Public Sector. Formazione continua su tecnologie moderne per la creazione di soluzioni software personalizzate ed efficienti e sugli agenti.

💼

06/2022 - 12/2024

Analista software e Back End Developer Associate Consultant

Links Management and Technology SpA

Esperienza nell'analisi di sistemi software as-is e flussi ETL utilizzando PowerCenter. Formazione completata su Spring Boot per lo sviluppo di applicazioni backend moderne e scalabili. Sviluppatore Backend specializzato in Spring Boot, con esperienza in progettazione di database, analisi, sviluppo e testing dei task assegnati.

💼

02/2021 - 10/2021

Programmatore software

Adesso.it (prima era WebScience srl)

Esperienza nell'analisi AS-IS e TO-BE, evoluzioni SEO ed evoluzioni website per migliorare le performance e l'engagement degli utenti.

🎓

2018 - 2025

Laurea in Informatica

Università degli Studi di Bari Aldo Moro

Bachelor's degree in Computer Science, focusing on software engineering, algorithms, and modern development practices.

📚

2013 - 2018

Diploma - Sistemi Informativi Aziendali

Istituto Tecnico Commerciale di Maglie

Technical diploma specializing in Business Information Systems, combining IT knowledge with business management.

Contattami

Hai un progetto in mente? Parliamone! Compila il form qui sotto e ti risponderò al più presto.

* Campi obbligatori. I tuoi dati saranno utilizzati solo per rispondere alla tua richiesta.

Event Sourcing: State as an Immutable Sequence of Events

Consider how a bank works: Your account balance is not "a number in a database updated with each transaction". And the result of all the transactions that ever happened: deposits, withdrawals, transfers, interest. If you want to know the balance at 2pm yesterday, you can reconstruct it by replaying all transactions up to that point. This is exactly the principle ofEvent Sourcing.

Instead of saving the current state of an entity in the database and overwriting it every time edit, Event Sourcing save the sequence of events leading up to it to that state. The current state is achieved by "playing" events from the beginning. The result is a system with complete audit trail, possibility of time-travel queries, and a natural separation between writing (appending events) and reading (projections onto events).

What You Will Learn

Event Sourcing Architecture: Event Store, Aggregate, Event Stream
Implement an Aggregate with events in TypeScript
Event Store: how to structure the event database
Event Replay: Rebuild the state from scratch from events
Time-travel queries: status of the aggregate at any historical moment
EventStoreDB: the database designed for Event Sourcing
Event Sourcing trade-off: when to adopt it and when to avoid it

The Classic Model vs Event Sourcing

Let's compare the two approaches for an order management system:

I wait	CRUD Classic	Event Sourcing
What is saved	Current status (UPDATE record)	Sequence of events (INSERT-only)
Audit trails	No (or with separate tables)	Yes, natively and complete
Past state	No (you only see the current status)	Yes, replay of events up to T
Complexity	Low	Medium-High
Performance read	High (direct query)	Requires screenings (see CQRS)
Performance write	High	High (append-only)
Debugging	Hard (end state with no story)	Easy (event replay)

Fundamental Concepts

Aggregate: the Unit of Consistency

Un Aggregate and the consistency boundary in Event Sourcing. All the changes to the aggregate occur via methods that generate events. The state is always reconstructed by applying the events in sequence:

// TypeScript: implementazione di un Order Aggregate con Event Sourcing

// 1. Definisci gli eventi dell'Aggregate
type OrderEvent =
  | { type: 'OrderCreated'; orderId: string; customerId: string; createdAt: string }
  | { type: 'ItemAdded'; productId: string; quantity: number; unitPrice: number }
  | { type: 'ItemRemoved'; productId: string }
  | { type: 'OrderConfirmed'; confirmedAt: string }
  | { type: 'OrderCancelled'; reason: string; cancelledAt: string };

// 2. Lo stato dell'Aggregate
interface OrderState {
  id: string;
  customerId: string;
  items: Map<string, { quantity: number; unitPrice: number }>;
  status: 'Draft' | 'Confirmed' | 'Cancelled';
  totalAmount: number;
  createdAt: string;
}

// 3. Il reducer: applica un evento allo stato (pura funzione)
function applyOrderEvent(state: OrderState | null, event: OrderEvent): OrderState {
  switch (event.type) {
    case 'OrderCreated':
      return {
        id: event.orderId,
        customerId: event.customerId,
        items: new Map(),
        status: 'Draft',
        totalAmount: 0,
        createdAt: event.createdAt,
      };

    case 'ItemAdded': {
      const newItems = new Map(state!.items);
      newItems.set(event.productId, {
        quantity: event.quantity,
        unitPrice: event.unitPrice,
      });
      const total = Array.from(newItems.values())
        .reduce((sum, item) => sum + item.quantity * item.unitPrice, 0);
      return { ...state!, items: newItems, totalAmount: total };
    }

    case 'ItemRemoved': {
      const newItems = new Map(state!.items);
      newItems.delete(event.productId);
      const total = Array.from(newItems.values())
        .reduce((sum, item) => sum + item.quantity * item.unitPrice, 0);
      return { ...state!, items: newItems, totalAmount: total };
    }

    case 'OrderConfirmed':
      return { ...state!, status: 'Confirmed' };

    case 'OrderCancelled':
      return { ...state!, status: 'Cancelled' };

    default:
      return state!;
  }
}

// 4. L'Aggregate: genera eventi in risposta a command
class OrderAggregate {
  private state: OrderState | null = null;
  private uncommittedEvents: OrderEvent[] = [];
  private version: number = 0;

  // Ricostruisce l'aggregate da una sequenza di eventi storici
  static rehydrate(events: OrderEvent[]): OrderAggregate {
    const aggregate = new OrderAggregate();
    for (const event of events) {
      aggregate.apply(event);
      aggregate.version++;
    }
    aggregate.uncommittedEvents = []; // pulizia: gli eventi storici non sono "nuovi"
    return aggregate;
  }

  // Metodo business: crea un nuovo ordine
  create(orderId: string, customerId: string): void {
    if (this.state !== null) {
      throw new Error('Order already created');
    }
    this.raiseEvent({
      type: 'OrderCreated',
      orderId,
      customerId,
      createdAt: new Date().toISOString(),
    });
  }

  // Metodo business: aggiunge un articolo
  addItem(productId: string, quantity: number, unitPrice: number): void {
    if (this.state?.status !== 'Draft') {
      throw new Error('Cannot add items to a non-draft order');
    }
    this.raiseEvent({ type: 'ItemAdded', productId, quantity, unitPrice });
  }

  // Metodo business: conferma l'ordine
  confirm(): void {
    if (this.state?.status !== 'Draft') {
      throw new Error('Only draft orders can be confirmed');
    }
    if (this.state.items.size === 0) {
      throw new Error('Cannot confirm empty order');
    }
    this.raiseEvent({ type: 'OrderConfirmed', confirmedAt: new Date().toISOString() });
  }

  getUncommittedEvents(): OrderEvent[] {
    return [...this.uncommittedEvents];
  }

  clearUncommittedEvents(): void {
    this.uncommittedEvents = [];
  }

  getState(): OrderState {
    if (!this.state) throw new Error('Order not initialized');
    return this.state;
  }

  get currentVersion(): number {
    return this.version;
  }

  private raiseEvent(event: OrderEvent): void {
    this.apply(event);
    this.uncommittedEvents.push(event);
    this.version++;
  }

  private apply(event: OrderEvent): void {
    this.state = applyOrderEvent(this.state, event);
  }
}

Event Store: The Event Database

Un Event Store and an append-only database optimized for writing and read sequences of events. The fundamental structure and theEvent Stream: an ordered sequence of events for a single Aggregate (identified by its ID).

// Schema dell'Event Store con PostgreSQL
CREATE TABLE event_store (
  id          BIGSERIAL PRIMARY KEY,
  stream_id   TEXT NOT NULL,           -- "Order-{orderId}"
  event_type  TEXT NOT NULL,
  event_data  JSONB NOT NULL,
  metadata    JSONB,
  version     BIGINT NOT NULL,         -- posizione nell'event stream
  created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  -- Previene concurrent writes con lo stesso version number
  CONSTRAINT uq_stream_version UNIQUE (stream_id, version)
);

-- Index per lettura efficiente di uno stream
CREATE INDEX idx_event_store_stream ON event_store (stream_id, version ASC);

-- Index per proiezioni su tipo di evento
CREATE INDEX idx_event_store_type ON event_store (event_type, created_at);

Event Sourcing Repository

// TypeScript: EventSourcedRepository con ottimistic concurrency
class OrderRepository {
  constructor(private readonly db: Database) {}

  // Carica un Order dal suo stream di eventi
  async findById(orderId: string): Promise<OrderAggregate | null> {
    const streamId = `Order-${orderId}`;
    const rows = await this.db.query(
      'SELECT event_type, event_data, version FROM event_store WHERE stream_id = $1 ORDER BY version ASC',
      [streamId]
    );

    if (rows.length === 0) return null;

    const events = rows.map((row) => ({
      type: row.event_type,
      ...row.event_data,
    })) as OrderEvent[];

    return OrderAggregate.rehydrate(events);
  }

  // Salva i nuovi eventi generati dall'Aggregate
  async save(aggregate: OrderAggregate): Promise<void> {
    const uncommittedEvents = aggregate.getUncommittedEvents();
    if (uncommittedEvents.length === 0) return;

    const orderId = aggregate.getState().id;
    const streamId = `Order-${orderId}`;
    // version corrente = version dopo rehydrate
    let expectedVersion = aggregate.currentVersion - uncommittedEvents.length;

    const client = await this.db.connect();
    try {
      await client.query('BEGIN');

      for (const event of uncommittedEvents) {
        expectedVersion++;
        await client.query(
          `INSERT INTO event_store (stream_id, event_type, event_data, version)
           VALUES ($1, $2, $3, $4)`,
          [streamId, event.type, JSON.stringify(event), expectedVersion]
        );
      }

      await client.query('COMMIT');
      aggregate.clearUncommittedEvents();
    } catch (err) {
      await client.query('ROLLBACK');
      // Se viola il UNIQUE constraint su (stream_id, version) = conflitto concorrente
      if ((err as any).code === '23505') {
        throw new Error(`Optimistic concurrency conflict on stream ${streamId}`);
      }
      throw err;
    } finally {
      client.release();
    }
  }
}

Time-Travel Queries

One of the most powerful advantages of Event Sourcing is the ability to reconstruct state of the aggregate at any historical moment:

// Ricostruisci lo stato dell'ordine alle 14:00 di ieri
async function getOrderStateAt(orderId: string, timestamp: Date): Promise<OrderState> {
  const streamId = `Order-${orderId}`;

  // Carica solo gli eventi antecedenti o uguali al timestamp
  const rows = await db.query(
    `SELECT event_type, event_data FROM event_store
     WHERE stream_id = $1 AND created_at <= $2
     ORDER BY version ASC`,
    [streamId, timestamp.toISOString()]
  );

  const events = rows.map((row) => ({
    type: row.event_type,
    ...row.event_data,
  })) as OrderEvent[];

  const aggregate = OrderAggregate.rehydrate(events);
  return aggregate.getState();
}

// Esempio: "Qual era il totale dell'ordine prima dell'ultima modifica?"
const stateYesterday = await getOrderStateAt(
  'order-789',
  new Date('2026-03-19T14:00:00Z')
);
console.log(`Totale ieri alle 14:00: ${stateYesterday.totalAmount} EUR`);

EventStoreDB: The Native Database for Event Sourcing

EventStoreDB and a database designed specifically for Event Sourcing. Provides event streams as native primitives, subscriptions for real-time notifications, and server-side projections:

// Connessione a EventStoreDB con il client TypeScript
import { EventStoreDBClient, jsonEvent } from "@eventstore/db-client";

const client = EventStoreDBClient.connectionString(
  "esdb://localhost:2113?tls=false"
);

// Scrivi eventi su uno stream
async function appendOrderEvents(
  orderId: string,
  events: OrderEvent[],
  expectedVersion: bigint
): Promise<void> {
  const streamName = `Order-${orderId}`;

  const esdbEvents = events.map((event) =>
    jsonEvent({
      type: event.type,
      data: event,
      metadata: {
        correlationId: crypto.randomUUID(),
        timestamp: new Date().toISOString(),
      },
    })
  );

  await client.appendToStream(streamName, esdbEvents, {
    expectedRevision: expectedVersion,  // optimistic concurrency
  });
}

// Leggi tutti gli eventi di uno stream
async function readOrderStream(orderId: string): Promise<OrderEvent[]> {
  const streamName = `Order-${orderId}`;
  const events: OrderEvent[] = [];

  const readResult = client.readStream(streamName, {
    direction: "forwards",
    fromRevision: "start",
  });

  for await (const resolvedEvent of readResult) {
    if (resolvedEvent.event?.data) {
      events.push(resolvedEvent.event.data as OrderEvent);
    }
  }

  return events;
}

// Proiezione: conta gli ordini per status
// Eseguita server-side in EventStoreDB
const projection = `
fromAll()
  .when({
    $init: function() { return { confirmed: 0, cancelled: 0 }; },
    'OrderConfirmed': function(state, event) { state.confirmed++; },
    'OrderCancelled': function(state, event) { state.cancelled++; }
  })
  .outputState();
`;

Snapshot: Optimizing the Replay of Large Aggregates

If an aggregate has thousands of events, replay becomes slow. The Snapshots and a checkpoint: instead of starting from the beginning, it rebuilds from the last snapshot:

// Snapshot ogni 100 eventi
const SNAPSHOT_INTERVAL = 100;

async function findByIdWithSnapshot(orderId: string): Promise<OrderAggregate> {
  // 1. Cerca l'ultimo snapshot
  const snapshot = await snapshotStore.findLatest(`Order-${orderId}`);

  if (snapshot) {
    // 2. Carica solo gli eventi dopo lo snapshot
    const events = await eventStore.loadFrom(
      `Order-${orderId}`,
      snapshot.version + 1
    );
    // 3. Riapplica gli eventi recenti sopra lo snapshot
    return OrderAggregate.rehydrateFromSnapshot(snapshot.state, events);
  }

  // Nessun snapshot: replay dall'inizio
  const allEvents = await eventStore.loadAll(`Order-${orderId}`);
  return OrderAggregate.rehydrate(allEvents);
}

// Crea uno snapshot dopo ogni save
async function saveWithSnapshot(aggregate: OrderAggregate): Promise<void> {
  await orderRepo.save(aggregate);

  // Crea snapshot ogni N eventi
  if (aggregate.currentVersion % SNAPSHOT_INTERVAL === 0) {
    await snapshotStore.save({
      streamId: `Order-${aggregate.getState().id}`,
      version: aggregate.currentVersion,
      state: aggregate.getState(),
      createdAt: new Date().toISOString(),
    });
  }
}

Event Sourcing trade-off

When Event Sourcing Makes Sense

Mandatory audit trail: Financial systems, healthcare systems, legal systems where the complete story is a requirement
Complex Debugging: When you want to be able to "rewind the tape" and understand how you got to a problematic state
Temporal business intelligence: “How many orders were in Draft status at 4pm yesterday?”
Event-driven integration: If you already have an EDA architecture, Event Sourcing integrates naturally

When Event Sourcing DOESN'T Make Sense

Simple CRUD: A master record management system without audit requirements does not benefit from ES
Complex queries: ES optimizes writes; reads require CQRS with projection (additional complexity)
Team without ES experience: The learning curve is significant; poorly managed complexity can outweigh the benefits
Rigid scheme: If your event schema changes frequently, version management becomes complex

Conclusions and Next Steps

Event Sourcing transforms persistence from a state update to an event append immutable. The result is a system with native audit trail, time-travel queries, and a natural separation between writing and reading. Price and complexity: the replay of events, managing schema versions, and requiring CQRS for queries complex.

The next article — CQRS — addresses exactly this challenge: how to build a layer optimized reading model (read model) that synchronizes with the event store via projections, allowing fast queries without touching the event stream.

Upcoming Articles in the Event-Driven Architecture Series

Related Series

EDA Fundamentals — the context in which Event Sourcing is used
Apache Kafka — Alternative distributed event store for high-volume streams