Ciao! Sono

Federico Calò

Sviluppatore Software | Divulgatore Tecnico

Creo applicazioni web moderne e strumenti digitali personalizzati per aiutare le attività a crescere attraverso l'innovazione tecnologica. La mia passione è unire informatica ed economia per generare valore reale.

Contattami

Chi Sono

La mia passione per l'informatica è nata tra i banchi dell'Istituto Tecnico Commerciale di Maglie, dove ho scoperto il potere della programmazione e il fascino di creare soluzioni digitali. Fin da subito, ho capito che l'informatica non era solo codice, ma uno strumento straordinario per trasformare idee in realtà.

Durante gli studi superiori in Sistemi Informativi Aziendali, ho iniziato a intrecciare informatica ed economia, comprendendo come la tecnologia possa essere il motore della crescita per qualsiasi attività. Questa visione mi ha accompagnato all'Università degli Studi di Bari, dove ho conseguito la Laurea in Informatica, approfondendo le mie competenze tecniche e la mia passione per lo sviluppo software.

Oggi metto questa esperienza al servizio di imprese, professionisti e startup, creando soluzioni digitali su misura che automatizzano processi, ottimizzano risorse e aprono nuove opportunità di business. Perché la vera innovazione inizia quando la tecnologia incontra le esigenze reali delle persone.

Le Mie Competenze

Analisi Dati & Modelli Previsionali

Trasformo i dati in insights strategici con analisi approfondite e modelli predittivi per decisioni informate

Automazione Processi

Creo strumenti personalizzati che automatizzano operazioni ripetitive e liberano tempo per attività a valore aggiunto

Sistemi Custom

Sviluppo sistemi software su misura, dalle integrazioni tra piattaforme alle dashboard personalizzate

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

Dicembre 2024

Visualizza

Master SQL

RoadMap.sh

Novembre 2024

Visualizza

Oracle Certified Foundations Associate

Oracle

Ottobre 2024

Visualizza

People Leadership Credential

Connect

Settembre 2024

💻 Linguaggi & Tecnologie

☕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.

Autonomous Property Management with AI Agents

Traditional property management is a labor-intensive sector: a property manager handles an average of 200-300 units with almost entirely manual processes (tenant communications, maintenance orders, rent collection, lease renewals). AI agents are radically changing this equation: systems like IBM Maximo applied to property management reduce unplanned downtime by 50% and maintenance costs by 10-40%.

In this article, we build an autonomous property management system with AI agents: a multi-channel tenant chatbot, a predictive maintenance system with IoT sensors, workflow automation, and an ML-based dynamic rental pricing system.

What You'll Learn

Multi-agent architecture for property management: orchestration and tool use
Tenant chatbot with LLM: handling requests, maintenance, payments
Predictive maintenance: IoT sensor data pipeline and anomaly detection
Dynamic pricing: ML model for rental optimization
Workflow automation: approvals, leases, communications
Building digital twin: simulation and operations optimization
CMMS integration (Computerized Maintenance Management System)
KPI tracking and automatic reporting for real estate portfolios

Multi-Agent Architecture for Property Management

An autonomous property management system consists of multiple specialized agents that cooperate. We use the orchestrator + worker agents pattern: a central agent coordinates request routing, while specialized agents handle specific domains (maintenance, payments, tenant relations, compliance).

import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env['OPENAI_API_KEY'] });

// Tool definitions for the property manager agent
const propertyManagementTools = [
  {
    type: 'function' as const,
    function: {
      name: 'create_maintenance_request',
      description: 'Create a maintenance work order for a unit',
      parameters: {
        type: 'object',
        properties: {
          unit_id: { type: 'string' },
          category: {
            type: 'string',
            enum: ['plumbing', 'electrical', 'hvac', 'appliance', 'structural', 'other'],
          },
          priority: {
            type: 'string',
            enum: ['emergency', 'urgent', 'normal', 'low'],
          },
          description: { type: 'string' },
          preferred_time: { type: 'string' },
        },
        required: ['unit_id', 'category', 'priority', 'description'],
      },
    },
  },
  {
    type: 'function' as const,
    function: {
      name: 'check_rent_status',
      description: 'Check rent payment status for a tenant',
      parameters: {
        type: 'object',
        properties: { tenant_id: { type: 'string' } },
        required: ['tenant_id'],
      },
    },
  },
  {
    type: 'function' as const,
    function: {
      name: 'escalate_to_human',
      description: 'Escalate the request to a human property manager',
      parameters: {
        type: 'object',
        properties: {
          reason: { type: 'string' },
          urgency: { type: 'string', enum: ['high', 'medium', 'low'] },
          conversation_summary: { type: 'string' },
        },
        required: ['reason', 'urgency'],
      },
    },
  },
];

export class TenantAssistantAgent {
  private conversations = new Map<string, OpenAI.ChatCompletionMessageParam[]>();

  async handleMessage(
    tenantId: string,
    unitId: string,
    message: string
  ): Promise<string> {
    const history = this.conversations.get(tenantId) ?? [];

    const messages: OpenAI.ChatCompletionMessageParam[] = [
      {
        role: 'system',
        content: `You are the virtual property management assistant for tenant #123;tenantId}
        of unit #123;unitId}. Be friendly, professional and resolve issues efficiently.
        You can create maintenance requests, check payments, and provide information.
        For emergencies (gas leak, flood, fire) always escalate immediately.`,
      },
      ...history,
      { role: 'user', content: message },
    ];

    let response = await openai.chat.completions.create({
      model: 'gpt-4o',
      messages,
      tools: propertyManagementTools,
      tool_choice: 'auto',
    });

    let assistantMessage = response.choices[0].message;

    // Agentic loop: execute tools until agent is done
    while (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
      messages.push(assistantMessage);

      const toolResults: OpenAI.ChatCompletionMessageParam[] = [];

      for (const toolCall of assistantMessage.tool_calls) {
        const result = await this.executeTool(
          toolCall.function.name,
          JSON.parse(toolCall.function.arguments)
        );
        toolResults.push({
          role: 'tool',
          tool_call_id: toolCall.id,
          content: JSON.stringify(result),
        });
      }

      messages.push(...toolResults);
      response = await openai.chat.completions.create({
        model: 'gpt-4o',
        messages,
        tools: propertyManagementTools,
      });
      assistantMessage = response.choices[0].message;
    }

    const replyText = assistantMessage.content ?? 'Please try again later.';
    const updatedHistory = [...history, { role: 'user' as const, content: message }, assistantMessage];
    this.conversations.set(tenantId, updatedHistory.slice(-20));

    return replyText;
  }

  private async executeTool(name: string, args: Record<string, unknown>): Promise<unknown> {
    switch (name) {
      case 'create_maintenance_request':
        return {
          success: true,
          workOrderId: `WO-#123;Date.now()}`,
          message: `Work order created. A technician will contact you within #123;
            args['priority'] === 'emergency' ? '2 hours' :
            args['priority'] === 'urgent' ? '24 hours' : '3-5 business days'
          }.`,
        };
      case 'check_rent_status':
        return { status: 'paid', amount: 1200, paidDate: '2026-03-01', balance: 0 };
      case 'escalate_to_human':
        return { success: true, ticketId: `ESC-#123;Date.now()}`, message: 'A property manager will contact you shortly.' };
      default:
        return { error: 'Unknown tool' };
    }
  }
}

Predictive Maintenance with IoT and ML

Predictive maintenance is the most economically impactful use case. IoT sensors continuously monitor HVAC systems, elevators, pumps, and electrical systems, and ML models predict failures before they occur, enabling scheduled interventions instead of costly emergencies.

import * as tf from '@tensorflow/tfjs-node';

interface SensorReading {
  sensorId: string;
  equipmentId: string;
  equipmentType: 'hvac' | 'elevator' | 'pump' | 'electrical_panel' | 'boiler';
  timestamp: string;
  metrics: {
    temperature?: number;      // Celsius
    vibration?: number;        // m/s^2
    current?: number;          // Ampere
    pressure?: number;         // bar
    runningHours?: number;     // total running hours
  };
}

interface MaintenancePrediction {
  equipmentId: string;
  failureProbability: number;  // 0-1
  estimatedDaysToFailure: number;
  alertLevel: 'normal' | 'watch' | 'warning' | 'critical';
  recommendedAction: string;
}

export class PredictiveMaintenanceEngine {
  private model: tf.LayersModel | null = null;

  async initialize(): Promise<void> {
    this.model = await tf.loadLayersModel('file://./models/equipment-failure/model.json');
  }

  async predictFailure(
    equipmentId: string,
    readings: SensorReading[]
  ): Promise<MaintenancePrediction> {
    if (!this.model) throw new Error('Model not initialized');

    const features = this.extractFeatures(readings);
    const inputTensor = tf.tensor3d([features], [1, features.length, 10]);

    const prediction = this.model.predict(inputTensor) as tf.Tensor;
    const [failureProb] = await prediction.data();
    tf.dispose([inputTensor, prediction]);

    const alertLevel = this.getAlertLevel(failureProb);

    return {
      equipmentId,
      failureProbability: failureProb,
      estimatedDaysToFailure: Math.max(0, Math.round((1 - failureProb) * 30)),
      alertLevel,
      recommendedAction: this.getRecommendedAction(alertLevel),
    };
  }

  private extractFeatures(readings: SensorReading[]): number[][] {
    // Extract statistical features from rolling windows (60min, 6h, 24h)
    const windows = [60, 360, 1440];
    return windows.map(w => {
      const windowed = readings.slice(-w);
      const temps = windowed.map(r => r.metrics.temperature ?? 0);
      const vibs = windowed.map(r => r.metrics.vibration ?? 0);
      const amps = windowed.map(r => r.metrics.current ?? 0);
      const mean = (a: number[]) => a.reduce((x, y) => x + y, 0) / (a.length || 1);
      const max = (a: number[]) => Math.max(...a, 0);
      return [mean(temps), max(temps), mean(vibs), max(vibs), mean(amps), max(amps)];
    }).flat().map(v => [v]);
  }

  private getAlertLevel(prob: number): MaintenancePrediction['alertLevel'] {
    if (prob >= 0.85) return 'critical';
    if (prob >= 0.65) return 'warning';
    if (prob >= 0.40) return 'watch';
    return 'normal';
  }

  private getRecommendedAction(level: string): string {
    const actions: Record<string, string> = {
      critical: 'Urgent intervention required. Contact technician immediately.',
      warning: 'Schedule inspection within next 7 days.',
      watch: 'Increase inspection frequency. Monitor trends closely.',
      normal: 'Operating normally. Continue routine maintenance.',
    };
    return actions[level] ?? actions['normal'];
  }
}

Dynamic Pricing: Rental Optimization with ML

Dynamic rental pricing uses ML models to maximize overall portfolio revenue, balancing occupancy and revenue per unit, inspired by Revenue Management models from the hotel industry adapted to real estate specifics (longer contracts, less frequent turnover).

export function calculateOptimalRent(input: RentalPricingInput): {
  recommendedRent: number;
  priceRange: { min: number; max: number };
  occupancyForecast: number;
  annualRevenueProjection: number;
  reasoning: string[];
} {
  const { marketData, tenantProfile } = input;
  const reasoning: string[] = [];

  // 1. Market baseline: median comparables
  const sorted = [...marketData.comparableRents].sort((a, b) => a - b);
  const median = sorted[Math.floor(sorted.length / 2)];
  let rent = median;
  reasoning.push(`Market baseline (comparable median): #123;median}`);

  // 2. Supply/demand adjustment
  if (marketData.demandIndex > 0.7) {
    const premium = Math.round(rent * 0.05);
    rent += premium;
    reasoning.push(`+#123;premium} for high demand (index: #123;(marketData.demandIndex * 100).toFixed(0)}%)`);
  } else if (marketData.vacancyRateNeighborhood > 0.08) {
    const discount = Math.round(rent * 0.03);
    rent -= discount;
    reasoning.push(`-#123;discount} for high neighborhood vacancy`);
  }

  // 3. Seasonality
  rent = Math.round(rent * marketData.seasonalityFactor);
  if (marketData.seasonalityFactor !== 1) {
    reasoning.push(`Seasonal factor: x#123;marketData.seasonalityFactor}`);
  }

  // 4. Quality tenant loyalty discount
  if (tenantProfile?.paymentHistory === 'excellent' && tenantProfile.yearsAsReliableTenant >= 2) {
    const discount = Math.round(rent * 0.02);
    rent -= discount;
    reasoning.push(`-#123;discount} loyalty discount for excellent tenant`);
  }

  // 5. Occupancy forecast
  const baseOccupancy = 0.95 - (marketData.vacancyRateNeighborhood * 0.5);
  const ratio = rent / median;
  const occupancyForecast = Math.max(0.5, Math.min(1.0, baseOccupancy * (1 - (ratio - 1) * 0.8)));

  return {
    recommendedRent: rent,
    priceRange: { min: Math.round(rent * 0.95), max: Math.round(rent * 1.05) },
    occupancyForecast,
    annualRevenueProjection: Math.round(rent * 12 * occupancyForecast),
    reasoning,
  };
}

Automation ROI Metrics

Process	Manual (200 units/year)	AI Automated	Savings
Tenant request handling	800 hours	50 hours (oversight)	-94%
Maintenance scheduling	300 hours	20 hours	-93%
Rent collection & follow-up	200 hours	10 hours	-95%
Monthly portfolio reports	120 hours	2 hours	-98%
Reactive vs predictive maintenance	€15,000/year	€9,000/year	-40%

Human Oversight: AI Augments, Does Not Replace

Despite advanced automation, the human property manager remains essential for complex decisions: evictions, legal disputes, contract renegotiation, key vendor relationships. Always configure clear escalation thresholds and proceed with human review for decisions impacting tenant welfare. AI must augment the manager's capacity, not eliminate it.

Conclusions

Autonomous property management with AI agents is no longer science fiction: it is implementable today with mature tools like GPT-4o for tenant chatbot, TensorFlow for predictive maintenance, and Apache Kafka for data streaming. The ROI is measurable and significant: portfolios of 200 units can be managed with the same effectiveness as 500 units, freeing managers for high-value activities (acquisitions, investor relations, portfolio growth).