Automatización con ASP.NET Core y Power Automate

En muchas empresas, solicitar un curso de formación sigue siendo un proceso manual: un correo aquí, una hoja de cálculo allá, un recordatorio que se pierde. El resultado es siempre el mismo: solicitudes olvidadas, falta de seguimiento y tiempo administrativo desperdiciado.
Este proyecto nace para resolver exactamente ese problema. La idea es sencilla: el usuario rellena una solicitud, la API la procesa automáticamente y, sin intervención humana, tanto el usuario como el coordinador reciben un email con todos los detalles.

¿Qué vamos a construir?

Una API REST con ASP.NET Core (.NET 8) que recibe y valida las solicitudes.
Un flujo en Power Automate que se activa automáticamente y envía los emails.
La conexión entre ambos a través de un webhook HTTP.

Arquitectura del sistema:

Swagger UI (cliente)
       ↓
ASP.NET Core API (.NET 8)
       ↓
Power Automate (webhook HTTP)
       ↓
Email al usuario + Email al coordinador

Desarrollo paso a paso

Paso 1 — Crear el proyecto ASP.NET Core

Abrimos Visual Studio y creamos un nuevo proyecto de tipo ASP.NET Core Web API con .NET 8. También se puede hacer desde terminal:

dotnet new webapi -n TrainingRequestAPI --no-openapi
cd TrainingRequestAPI
dotnet add package Swashbuckle.AspNetCore

La estructura del proyecto queda así:

TrainingRequestAPI/
├── Controllers/
│   └── TrainingController.cs
├── Models/
│   └── TrainingRequest.cs
│   └── TrainingResponse.cs
├── Services/
│   └── PowerAutomateService.cs
├── Program.cs
└── appsettings.json

Paso 2 — Definir el modelo de datos

El modelo representa los datos que recibirá la API en cada solicitud:

public class TrainingRequest
{
    public string Name { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public string Course { get; set; } = string.Empty;
    public string Level { get; set; } = string.Empty;
}

Y la respuesta que devuelve la API al cliente:

public class TrainingResponse
{
    public string RequestId { get; set; } = string.Empty;
    public string Message { get; set; } = string.Empty;
    public string Status { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
}

Paso 3 — Crear el servicio de Power Automate

Este servicio es el puente entre la API y Power Automate. Cuando llega una solicitud válida, construye un payload JSON y lo envía al webhook:

public async Task<bool> TriggerFlowAsync(TrainingRequest request, string requestId)
{
    if (string.IsNullOrEmpty(_webhookUrl))
        return false;

    var payload = new
    {
        requestId,
        name = request.Name,
        email = request.Email,
        course = request.Course,
        level = request.Level,
        createdAt = DateTime.UtcNow.ToString("dd/MM/yyyy HH:mm")
    };

    var json = JsonSerializer.Serialize(payload);
    var content = new StringContent(json, Encoding.UTF8, "application/json");
    var response = await _httpClient.PostAsync(_webhookUrl, content);
    return response.IsSuccessStatusCode;
}

Paso 4 — Crear el controlador

El controlador expone el endpoint POST /api/training. Valida los campos obligatorios, genera un ID único para cada solicitud y delega en el servicio de Power Automate:

[HttpPost]
public async Task<IActionResult> Create([FromBody] TrainingRequest request)
{
    if (string.IsNullOrWhiteSpace(request.Name) ||
        string.IsNullOrWhiteSpace(request.Email) ||
        string.IsNullOrWhiteSpace(request.Course))
    {
        return BadRequest(new { Error = "Name, Email y Course son obligatorios." });
    }

    var requestId = $"TRN-{DateTime.UtcNow:yyyy}-{Guid.NewGuid().ToString()[..6].ToUpper()}";
    var triggered = await _powerAutomate.TriggerFlowAsync(request, requestId);

    return Ok(new TrainingResponse
    {
        RequestId = requestId,
        Message = "Solicitud recibida correctamente. Recibirás un email de confirmación.",
        Status = triggered ? "Procesada" : "Registrada",
        CreatedAt = DateTime.UtcNow
    });
}

El ID generado sigue el formato TRN-2026-XXXXXX, lo que facilita el seguimiento de cada solicitud.

Paso 5 — Configurar el flujo en Power Automate

En Power Automate creamos un nuevo Flujo de nube automatizado.

Le ponemos el nombre Training Request – Notificaciones Email.

Formulario de creación con el nombre del flujo

Elegir el trigger: buscamos «HTTP» y seleccionamos «Cuando se recibe una solicitud HTTP».

Búsqueda del trigger HTTP

Configurar el trigger: pegamos el esquema JSON que define los campos que recibirá el flujo desde nuestra API:

{
  "type": "object",
  "properties": {
    "requestId": { "type": "string" },
    "name": { "type": "string" },
    "email": { "type": "string" },
    "course": { "type": "string" },
    "level": { "type": "string" },
    "createdAt": { "type": "string" }
  }
}

Trigger configurado con el esquema JSON

Paso 6 — Añadir las acciones de email

Añadimos dos acciones «Enviar correo electrónico (V2)» de Office 365 Outlook en serie.

Búsqueda de la acción de email, Office 365 Outlook

Primer email — al usuario: usamos los valores dinámicos del trigger (name, email, course, level, requestId) para personalizar el mensaje.

Configuración del email al usuario con valores dinámicos

Segundo email — al coordinador: mismo formato pero dirigido a la persona responsable de gestionar las solicitudes.

Configuración del email al coordinador

El flujo completo, una vez guardado, queda así: nombramos las acciones (pasos) que componen el proceso, las cuales se ejecutan secuencialmente tras el desencadenador inicial

Vista general del flujo con los tres bloques

Paso 7 — Conectar la API con Power Automate

Al guardar el flujo, Power Automate genera la URL del webhook. La copiamos y la pegamos en el archivo appsettings.json del proyecto:

URL del webhook generada en el trigger

appsettings.json en Visual Studio con la URL configurada

Paso 8 — Prueba completa desde Swagger

Arrancamos la API con dotnet run y abrimos Swagger en el navegador. Enviamos una solicitud de prueba:

{
  "name": "Pepe",
  "email": "test@email.com",
  "course": "Azure Fundamentals",
  "level": "Básico"
}

La API responde con 200 OK y el ID generado. Segundos después llegan los dos emails.

Recomendaciones

En un entorno de producción, proteger el webhook con autenticación (Azure AD, API key o firma HMAC) en lugar de dejarlo abierto a cualquiera.
Centralizar toda la configuración sensible (URLs, credenciales) en variables de entorno o Azure Key Vault, nunca en el código fuente.
Añadir validación del formato de email en el modelo antes de llamar a Power Automate.
Registrar cada solicitud en una base de datos para poder hacer seguimiento histórico.

¿Crees que este tipo de automatización tiene sentido en tu empresa? ¿Qué otros procesos manuales podrían resolverse con una arquitectura similar? Déjalo en los comentarios.

Autora: Salima Agmir Achabbab
Máster: Desarrollo Full Stack + Arquitecturas Cloud
Centro: Tajamar Tech

Recurso: Documentación oficial de Microsoft Power Automate – Power Automate | Microsoft Learn
Año académico: 2025-2026
Código: Enlace a GitHub
LinkedIn: salima-agmir