Franco Dorrego
@frfrand · En ArduMaker desde enero de 2026
Franco Dorrego construye con ArduMaker desde enero de 2026. Sus artículos en el blog de ArduMaker, del más nuevo al más viejo:
Artículos que escribió
- Cómo entregar una aplicación a otro equipo sin depender del desarrollador: Checklist de repositorios, documentación, secretos, infraestructura, CI/CD, acceso y pruebas para un traspaso de software.
- SMTP vs API de correo: entrega fiable de emails transaccionales: Diferencias entre SMTP y API para emails de aplicaciones, rebotes, reintentos, colas, SPF, DKIM y DMARC.
- Contrato de mantenimiento de software: soporte, SLA y responsabilidades: Qué definir en alcance, disponibilidad, tiempos de respuesta, backups, seguridad, costes y salida del proveedor.
- Mi aplicación web se cayó: plan de respuesta a incidentes: Guía operativa para contener, diagnosticar, recuperar y comunicar una caída de aplicación con un equipo pequeño.
- Tu backup existe, pero ¿se restaura? Prueba de recuperación completa: Procedimiento para restaurar código, PostgreSQL, archivos, secretos y servicios en un entorno aislado, con medición de RTO y RPO.
- SEO multilingüe: hreflang y canonical para español, portugués e inglés: Cómo organizar URLs regionales, hreflang recíproco, canonicals y sitemaps sin errores de indexación en sitios multilingües.
- Muchas impresiones y pocos clics en Search Console: diagnóstico de CTR: Cómo interpretar impresiones, clics, posición y CTR segmentando consultas, páginas, dispositivos e intención de búsqueda.
- Core Web Vitals: optimiza LCP, INP y CLS antes de cambiar de hosting: Cómo diagnosticar LCP, INP y CLS con datos de campo y laboratorio, corregir el frontend y detectar cuellos de botella de servidor.
- Cambiar hosting y dominio sin perder SEO: guía de migración: Checklist de redirecciones 301, canonical, enlaces internos, DNS, sitemaps y seguimiento en Search Console al migrar una web.
- Google no indexa mi web React o Vite: diagnóstico de SEO técnico: Guía para diagnosticar por qué Google no indexa una SPA React/Vite: renderizado, códigos HTTP, rutas, metadatos, sitemap y Search Console.
- MCP para agencias de software: administrar VPS, dominios y despliegues con control: Casos prácticos de agentes MCP para gestionar infraestructura de varios clientes con aislamiento, permisos y confirmaciones.
- Cómo auditar un agente de IA que administra un VPS: permisos, logs y rollback: Registros auditables, aprobaciones y reversión segura de operaciones realizadas por agentes de IA sobre servidores.
- Cómo controlar el gasto de IA por cliente en una plataforma SaaS: Medición por empresa y proyecto, cuotas, alertas y límites de presupuesto para uso multiinquilino de modelos de IA.
- Qué hacer cuando falla una API de IA: fallback entre modelos y proveedores: Diseño resiliente de servicios de IA con timeouts, modelos alternativos, reintentos, observabilidad y límites de calidad.
- Cómo elegir un modelo de IA para cada tarea: costo, velocidad y calidad: Método práctico para comparar modelos de IA según tareas, latencia, precisión, coste y restricciones de datos.
- Notificaciones de pedidos por WhatsApp sin mensajes duplicados: Arquitectura de eventos e idempotencia para avisos de compra, envío e incidencias por WhatsApp.
- Cómo conectar WhatsApp a un CRM y conservar el historial de cada cliente: Diseño de integración WhatsApp-CRM con identificación de contactos, deduplicación, permisos y trazabilidad comercial.
- WhatsApp y Google Calendar: automatizar reservas sin duplicar citas: Flujo de disponibilidad, confirmación, reprogramación y cancelación con WhatsApp y Google Calendar sin reservas duplicadas.
- Chatbot de WhatsApp o agente de IA: cuál conviene para atender clientes: Comparación práctica entre reglas, IA conversacional, operadores humanos, costos y riesgos de automatización.
- WhatsApp Business API para pequeñas empresas: requisitos, costos y usos reales: Diferencias entre WhatsApp Business y su API, plantillas, consentimiento, precios e integraciones para pymes.
- Cuándo necesita Redis una aplicación: señales medibles antes de añadir caché o colas: Criterios para decidir si incorporar Redis para caché, sesiones y jobs, con métricas, alternativas y costes de operación.
- PostgreSQL sin conexiones disponibles: diagnóstico y connection pooling con PgBouncer: Identifica agotamiento de conexiones en PostgreSQL, investiga pg_stat_activity y decide cuándo configurar pooling y PgBouncer.
- PostgreSQL multiempresa: tres estrategias para aislar datos de clientes en un SaaS: Compara bases por cliente, esquemas independientes y tablas compartidas con tenant_id y RLS, con criterios de seguridad, coste y operación.
- Migrar Supabase Storage a S3 sin romper imágenes, permisos ni URLs: Plan práctico para migrar archivos desde Supabase Storage a S3 con inventario, claves, políticas, URLs, validación y reversión.
- Por qué aumenta mi factura de Supabase: base de datos, almacenamiento y transferencia: Aprende a identificar recursos facturables de Supabase, distinguir consumo normal de fugas y decidir cuándo optimizar o migrar.
- Cuánto cuesta mantener un SaaS 24/7: presupuesto de API, PostgreSQL, Redis y workers: Modelo de costes de un SaaS encendido todo el mes, con supuestos explícitos, costes ocultos y comparación entre PaaS y VPS.
- Vercel y los trabajos en segundo plano: cómo organizar colas, cron y tareas largas: Arquitectura práctica para separar frontend, funciones HTTP, jobs, colas y workers cuando las tareas no encajan en el tiempo de ejecución de Vercel.
- Por qué Render tarda en responder tras un tiempo sin visitas y cómo medirlo: Qué son los arranques en frío de Render, cómo medir la primera petición y cuándo usar un servicio de ejecución permanente.
- PostgreSQL en Railway: cómo probar una restauración antes de una emergencia: Guía para validar backups de PostgreSQL en Railway con restauraciones aisladas, integridad, extensiones, roles y un simulacro de recuperación.
- Railway me cobra más de lo esperado: cómo encontrar el servicio que aumenta tu factura: Aprende a analizar el gasto de Railway por servicio, CPU, RAM, tráfico y volúmenes, con criterios para decidir cuándo pasar a infraestructura de coste fijo.
- Mis automatizaciones n8n fallan y nadie se entera: alertas y monitoreo: Cómo detectar fallos en n8n, crear alertas, observar ejecuciones pendientes y medir la fiabilidad de automatizaciones.
- Cómo captar clientes con n8n: formularios, CRM y WhatsApp sin duplicados: Diseño de un flujo n8n para validar leads, deduplicar contactos, asignar comerciales y avisar por WhatsApp de forma segura.
- n8n vs Make vs Zapier: cómo elegir para procesos empresariales críticos: Comparativa equilibrada de n8n, Make y Zapier en coste, facilidad, control de datos, mantenimiento y procesos críticos.
- Cómo recuperar automatizaciones n8n después de una caída del servidor: Plan de recuperación de n8n con persistencia, PostgreSQL, volúmenes, cola de ejecuciones, reintentos y prevención de duplicados.
- Cuánta RAM necesita n8n en producción: workers, PostgreSQL y Redis: Cómo dimensionar n8n según ejecuciones, concurrencia, persistencia, memoria de los workflows y uso de workers.
- Auditoría de seguridad WordPress: checklist antes de contratar mantenimiento: Qué revisar en una auditoría WordPress: versiones, accesos, backups, permisos, vulnerabilidades y obligaciones del proveedor.
- WooCommerce lento: cómo descubrir el cuello de botella del checkout: Diagnóstico del checkout lento de WooCommerce: extensiones, consultas SQL, caché, terceros y recursos del servidor.
- Cómo migrar WordPress a un VPS sin perder correo, formularios ni SEO: Checklist para trasladar WordPress a un VPS manteniendo datos, DNS, HTTPS, correo electrónico, formularios y posicionamiento.
- WordPress vs React: seguridad, SEO y mantenimiento de una web corporativa: Comparativa práctica entre WordPress y React según contenido, SEO, seguridad, coste de mantenimiento y necesidades de negocio.
- WordPress infectado con malware: primeros pasos para recuperar una web empresarial: Qué hacer cuando una web WordPress ha sido comprometida: contención, evidencias, limpieza, restauración y prevención.
- De MVP a SaaS de pago: los 10 componentes que faltan para producción: Autenticación, planes, facturación, límites, soporte y operaciones para cobrar a usuarios reales.
- Shopify o ecommerce a medida: cómo elegir según tu negocio: Tiempo de lanzamiento, costes recurrentes, integraciones y control de procesos.
- Software para alquiler de salas: reservas, cobros y cerraduras inteligentes: Arquitectura y funciones para gestionar salas, horarios, eventos y acceso físico.
- Cuánto cuesta desarrollar un CRM a medida: qué determina el presupuesto: Módulos, automatización, integraciones y mantenimiento para estimar el coste real.
- Sistema de reservas online a medida: funciones que necesita tu negocio: Calendarios, cupos, pagos y cancelaciones para elegir entre plataforma genérica y software propio.
- Migrar una aplicación entre VPS sin perder datos: plan y rollback: Inventario, transferencia, sincronización, DNS y recuperación segura ante incidentes.
- Varios clientes en un VPS: cómo aislar aplicaciones, recursos y permisos: Arquitectura multiaplicación para un VPS compartido con límites y backups separados.
- Secretos y credenciales de clientes: accesos seguros sin compartir contraseñas: Gestión de claves, rotación, permisos y revocación entre equipos y proyectos.
- Desarrollo, staging y producción en un único VPS: aislamiento práctico: Cómo separar datos, secretos, dominios, despliegues y límites sin pagar tres servidores.
- Despliegue blue-green en un VPS: actualizar sin cortar el servicio: Cómo preparar dos versiones, comprobar salud, cambiar Nginx y volver atrás con seguridad.
- Emails, tareas cron y automatizaciones: completar una app hecha con IA: Cómo convertir una demo en un servicio funcional usando email transaccional, colas, cron, webhooks y n8n con reintentos.
- Pagos reales en una app hecha con IA: Stripe, webhooks e idempotencia: Cómo completar pagos de una app Lovable o vibe coding: confirmación en servidor, webhooks firmados, reservas y reintentos seguros.
- Seguridad para apps creadas con Lovable e IA: secretos, roles, RLS y JWT: Cómo auditar una app generada por IA: autenticación, permisos, RLS, JWT, claves API, CORS, uploads y tests por usuario.
- Checklist: 30 verificaciones antes de publicar una app hecha con Lovable o IA: 30 pasos para lanzar una aplicación creada con Lovable, Bolt, Cursor o ChatGPT: seguridad, backups, pagos, DNS y rollback.
- Desplegar Next.js creado con IA en un VPS: SSR, API Routes y Node.js: Next.js en VPS desde v0 o IA: build, runtime Node, reverse proxy, SSL, API Routes, systemd, logs y rollback.
- De datos simulados a PostgreSQL real: completar la base de una app hecha con IA: Cómo convertir un prototipo con mocks en una app PostgreSQL segura: esquema, integridad, migraciones, transacciones y backups.
- Node.js Express generado con IA: publicar una API estable sin caídas: Cómo llevar Node Express hecho con IA a producción: validación, logs, systemd, Nginx, variables privadas y rate limiting.
- API Python hecha con IA: pasar FastAPI o Django de desarrollo a producción: Cómo desplegar FastAPI y Django creados con IA: ASGI, WSGI, Postgres, migraciones, proxy HTTPS y pruebas de negocio.
- Migrar Base44 a un hosting propio: código exportado y backend que falta: Cómo salir de Base44: qué se exporta, qué sucede con autenticación, funciones, almacenamiento y APIs, y cómo presupuestar refactor.
- React + Vite creados con IA: publicar una SPA con Nginx, SSL y dominio: Cómo desplegar React Vite desde Lovable o Bolt: npm ci, build dist, try_files Nginx, HTTPS, variables y errores 404.
- De Google AI Studio o Gemini a una app real: desplegar API, frontend y datos: Pasar una app Gemini/Google AI Studio a producción: ocultar API keys, controlar costes, cuotas, archivos, backend y servidor.
- Diez errores de vibe coding que aparecen cuando una app recibe clientes reales: Los 10 errores más frecuentes al llevar una aplicación hecha con IA a producción y cómo detectarlos antes de perder datos.
- Pasar código creado con Cursor a producción: del editor a una app que no se cae: Checklist para desplegar proyectos hechos con Cursor: arquitectura, Git, tests, secretos, Docker, VPS y mantenimiento real.
- De ChatGPT o Codex a una web propia: publicar código de IA en producción: Cómo transformar una app escrita con ChatGPT/Codex en un sitio real: estructura, builds, GitHub, API, VPS, SSL y pruebas.
- Desplegar una app hecha con Claude Code: GitHub, servidores, dominios y backups: Pasos para convertir código de Claude Code en software en producción: CI/CD, systemd, secretos, VPS, pruebas y rollback.
- Cómo llevar una app de v0 a Next.js en producción fuera de Vercel: De v0 a un VPS: exportar Next.js, revisar componentes, SSR, APIs, variables privadas y publicar mediante Git con HTTPS.
- Migrar los datos de Bolt Cloud a PostgreSQL: pedidos, usuarios y storage: Cómo planificar una migración Bolt Cloud a PostgreSQL: modelo, exportación, integridad de datos, Auth, funciones y pruebas.
- Migrar Replit Agent a tu VPS: procesos, secretos, GitHub y dominio propio: De Replit Agent a un VPS con GitHub, procesos systemd, proxy Nginx, variables de entorno, bases y HTTPS.
- De Bolt.new a producción: GitHub, servidor y despliegue estable con ArduMaker: Cómo pasar una app Bolt.new a hosting propio: exportar GitHub, identificar backend Bolt Cloud y configurar VPS, SSL y deploys.
- Salir de Lovable sin perder usuarios: OAuth, sesiones y seguridad al migrar: Cómo migrar autenticación de Lovable: cuentas, OAuth, callbacks, sesiones, reset de contraseñas, RLS y pruebas de permisos.
- Pasar una web de Lovable a un VPS: Nginx, SSL y un dominio profesional: Cómo publicar una app de Lovable en un VPS ArduMaker: Nginx, HTTPS, SPA Vite o servidor TanStack Start y verificación de rutas.
- Migrar el dominio de Lovable sin perder SEO ni interrumpir una aplicación: Guía de DNS para salir de Lovable: dominio propio, HTTPS, Search Console, redirecciones, canonicals, TTL y rollback de despliegue.
- Migrar Lovable Cloud a Supabase propio: usuarios, datos, archivos y funciones: Migración de Lovable Cloud a Supabase: cómo recuperar tablas, RLS, usuarios, storage, Edge Functions, OAuth y secretos sin pérdida de datos.
- Cómo exportar Lovable a GitHub y desplegar el código fuera de Lovable en 2026: Exportar Lovable a GitHub: Git sync, ZIP, Vite o TanStack Start, dependencias, variables y pruebas para migrar sin romper la app.
- De Lovable a producción con ArduMaker: cómo tener una web propia, estable y mantenible: Guía para migrar una app de Lovable a producción: código, hosting, base de datos, dominio, SSL, despliegues, soporte y costes reales.
- ¿Quién descubre una CVE y qué pasa desde el reporte hasta el parche?: Guía práctica del descubrimiento de vulnerabilidades: investigadores, CNA, divulgación coordinada, CVE, parches y falsas alarmas.
- CVE-2024-21892 en Node.js: cómo un proceso puede heredar más privilegios de los debidos: CVE-2024-21892 explicada con ejemplos defensivos: capacidades Linux, impacto en Node.js, revisión de privilegios y actualización.
- CVE-2024-7592 en Python: cómo el análisis de cookies puede consumir CPU: Un DoS en http.cookies de Python: qué es complejidad cuadrática, cómo se detectó, dónde afecta y qué actualizar.
- CVE-2026-109619 en PHP: estado global reutilizado, sesiones y ejecución de código: Análisis práctico de CVE-2026-109619: qué falla en los workers PHP, versiones reparadas, mitigación temporal oficial y cómo actualizar.
- CVE-2026-109618 en PHP: fallo crítico de memoria, riesgo real y actualización urgente: CVE-2026-109618 explicada: descubrimiento, PHP afectados, riesgo de RCE por memoria OOM y medidas oficiales del 21 de octubre de 2026.
- CVE-2025-29927 en Next.js: por qué el middleware no debe ser tu única barrera de acceso: El bypass de middleware en Next.js explicado con escenarios reales, alcance por hosting, parches y recomendaciones de autorización.
- CVE-2024-42005 en Django: una SQL injection oculta detrás de JSONField: Cómo surgió un fallo de SQL injection en Django QuerySet, a qué versiones afectó, cuándo hay exposición y qué corregir.
- CVE-2025-49844 en Redis: por qué un fallo de Lua puede acabar en ejecución remota: Qué significa RediShell en Redis, quién lo reportó, requisitos de acceso, versiones corregidas y medidas para proteger un servicio.
- CVE-2025-1094 en PostgreSQL: cuándo una función de escape puede permitir SQL injection: Explicamos el caso de SQL injection en funciones de escape de PostgreSQL, alcance preciso, versiones corregidas y mitigaciones.
- CVE-2024-10924 en WordPress: cuando un plugin de seguridad permite entrar como administrador: El caso real de Really Simple Security: cómo se descubrió, quiénes estaban expuestos, cómo corregirlo y revisar accesos.
- CVE-2024-22019 en Node.js: cómo una petición HTTP puede saturar tu servidor: Explicación de CVE-2024-22019: denegación de servicio, servidores Node.js afectados, descubrimiento, detección y mitigación.
- CVE-2023-24329 en Python: URLs manipuladas y controles de seguridad que fallan: Una vulnerabilidad de urllib.parse explicada sin tecnicismos: detección, posibles abusos, versiones corregidas y buenas prácticas.
- CVE-2024-4577 en PHP: cómo funciona el fallo crítico de PHP-CGI en Windows: Qué es CVE-2024-4577, quién lo descubrió, cuándo afecta a PHP en Windows, cómo se aprovecha y cómo proteger tu web o servidor.
- Git cherry-pick: cómo pasar un commit a otra rama sin copiar todo: Mover una corrección puntual entre ramas con Git cherry-pick
- Checklist de despliegue: cómo actualizar una web y volver atrás si falla: Plan práctico de deploy, smoke tests, migraciones y rollback
- Por qué tu API va lenta: medir p95, consultas SQL y llamadas externas: Investigar latencia real con logs, tracing y percentiles
- Health checks de una API: por qué un 200 OK no garantiza que funcione: Diseñar liveness y readiness checks sin saturar la base de datos
- Prometheus y Grafana en un VPS: tres métricas que vale la pena monitorear: CPU, memoria, disco y alertas para aplicaciones en producción
- Cuánto cuesta usar una API de IA: calcular tokens y controlar presupuesto: Estimación de tokens, caché, límites y monitoreo de gasto por usuario
- RAG híbrido: combinar búsqueda semántica y por palabras sin respuestas inventadas: Búsqueda híbrida, filtros y citas para asistentes de IA con documentos
- n8n webhooks seguros: validar firmas, evitar duplicados y reintentar: Automatizaciones con webhooks, idempotencia y control de errores
- Errores HTTP 429: reintentos con backoff exponencial sin saturar una API: Retry-After, jitter e idempotencia en clientes HTTP
- Seguridad MCP: permisos mínimos para que una IA administre un VPS: Diseñar herramientas MCP seguras con scopes, aprobaciones y auditoría
- MCP tools, resources y prompts: qué puede hacer cada pieza de un servidor MCP: Explicar el protocolo MCP y cómo elegir tools, resources y prompts
- GitHub Actions secrets: desplegar sin publicar contraseñas ni claves: Configurar secretos CI y permisos mínimos en GitHub Actions
- Supabase RLS con ejemplos: cómo impedir que un usuario vea datos ajenos: Políticas RLS prácticas con auth.uid y pruebas de permisos
- SQLite vs PostgreSQL: cuándo migrar una app y qué cambia: Elegir base embebida o servidor PostgreSQL para un backend
- Redis y caché: cómo invalidar datos sin mostrar información vieja: TTL, claves y patrones de invalidación al cachear APIs
- PostgreSQL JSONB vs columnas normales: cuándo conviene cada opción: Modelado SQL y consultas a campos flexibles sin perder rendimiento
- Reservas duplicadas en PostgreSQL: transacciones y bloqueos para evitarlo: Evitar doble reserva y condiciones de carrera con transacciones SQL
- pg_dump y pg_restore: cómo hacer y comprobar backups de PostgreSQL: Copia lógica y restauración en PostgreSQL con comandos seguros
- EXPLAIN ANALYZE en PostgreSQL: encontrar consultas lentas paso a paso: Plan de ejecución e índices de PostgreSQL para optimizar APIs
- curl para APIs: probar headers, JSON, tiempos y certificados desde terminal: Comandos curl útiles para investigar errores web y HTTP
- TCP handshake vs TLS handshake: qué sucede antes de abrir una web HTTPS: Secuencia SYN y TLS, y diagnóstico de conexiones lentas
- Subredes /24, /26 y /27: aprender CIDR con ejemplos prácticos: Calcular rangos IPv4 y cantidad de direcciones útiles
- UFW vs nftables: cómo configurar el firewall de un VPS Linux: Reglas de acceso Ubuntu, SSH y puertos de API con mínimo privilegio
- Túnel SSH para PostgreSQL: conectarte sin abrir el puerto 5432: Acceso remoto seguro a Postgres mediante ssh -L en un VPS
- Certbot y Let's Encrypt: renovar HTTPS automáticamente sin romper tu web: Certificados gratuitos, renovación automática y diagnóstico TLS en Nginx
- dig y nslookup: cómo diagnosticar un dominio que no resuelve: Consultar servidores DNS, registros y caché desde terminal
- Registros DNS A, AAAA, CNAME, MX y TXT: ejemplos de cuándo usar cada uno: Tipos de registros DNS y errores comunes al conectar web y correo
- DNS TTL: cuánto tarda de verdad un cambio de IP y cómo prepararlo: Cambiar registros DNS sin romper una web ni perder tráfico
- Docker Compose en producción: volúmenes, redes y secretos sin sorpresas: Ejemplo de Compose con API y base, persistencia y logs
- Nginx 502 Bad Gateway: cómo encontrar el error real en tu servidor: Guía para diagnosticar 502 entre Nginx, Gunicorn y FastAPI
- Nginx reverse proxy con FastAPI: publicar una API con HTTPS: Configurar Nginx y Uvicorn en un VPS con TLS y upstream local
- Bash scripts seguros: set -euo pipefail, trap y códigos de salida: Evitar scripts de despliegue que fallan silenciosamente en Linux
- chmod y chown: cómo corregir permisos Linux sin usar 777: Permisos Unix usuarios grupos y seguridad de archivos en servidores
- Disco lleno en Ubuntu: diferencias entre df, du e inodos: Diagnóstico de espacio y de archivos pequeños en un VPS Linux
- Cómo saber qué proceso ocupa un puerto en Linux con ss y lsof: Descubrir puertos ocupados y servicios escuchando en Ubuntu
- journalctl explicado con ejemplos: encontrar errores de una app Linux: Buscar logs de servicios por unidad, prioridad y fecha con journalctl
- systemctl failed: cómo descubrir por qué un servicio Linux no arranca: Depurar servicios systemd con status, journalctl y permisos
- Cron vs systemd timers: cómo programar tareas en un servidor Linux: Diferencias entre cron y systemd timers para backups y automatización
- grep, sed y awk: tres comandos para encontrar problemas en los logs: Ejemplos útiles con grep sed awk para investigar errores en servidores
- WSL2 vs máquina virtual: cuál conviene para programar con Linux en Windows: Comparación práctica WSL2, Docker y VM para desarrollar en Linux
- Cómo configurar ssh-agent en Windows y usar claves SSH sin repetir contraseñas: SSH agent Windows 11, claves y autenticación remota en VPS
- Cómo probar una API REST con PowerShell e Invoke-RestMethod: Peticiones GET POST, JSON, autenticación y diagnóstico desde Windows
- PowerShell Test-NetConnection: comprobar puertos y conexiones en Windows: Diagnosticar conectividad a una API, SSH o PostgreSQL con PowerShell
- Deploy keys, SSH y tokens en GitHub: qué credencial usar para desplegar: Acceso seguro de servidores a repositorios GitHub sin compartir cuentas
- Git fetch vs pull: cómo actualizar tu repositorio sin sorpresas: Diferencias entre descargar referencias y fusionar cambios en Git
- Git tags y releases: cómo saber qué versión está en producción: Versionar despliegues y recuperar el commit exacto de una app
- Cómo usar .gitignore y evitar subir secretos a GitHub: Patrones gitignore, archivos ya versionados y rotación de secretos
- Git bisect: encontrar el commit que rompió tu aplicación: Búsqueda binaria del cambio que introdujo un fallo en producción
- Git revert, reset y restore: qué usar para deshacer cambios sin perder trabajo: Elegir entre revertir un commit, mover HEAD o recuperar un archivo
- Git stash: cómo guardar cambios sin hacer un commit: Guardar trabajo temporal en Git sin perder archivos ni mezclar ramas
- Cloudways vs RunCloud: hosting gestionado o panel de servidor: Cloudways vs RunCloud en proyectos WordPress y PHP
- HestiaCP vs CyberPanel: cuál elegir para administrar un VPS: HestiaCP vs CyberPanel con PHP, correo y mantenimiento
- cPanel vs Plesk: diferencias, funcionalidades y tipos de proyecto: cPanel y Plesk comparados para hosting y aplicaciones
- AWS Lightsail vs DigitalOcean: diferencias entre sus VPS: Lightsail vs DigitalOcean Droplets para proyectos web
- Linode vs DigitalOcean: diferencias para desarrolladores: Linode o DigitalOcean para ejecutar backend web
- DigitalOcean vs Vultr: cuál elegir para alojar una aplicación: DigitalOcean vs Vultr en una web con PostgreSQL
- VPS sin panel vs VPS administrado: qué cambia realmente: Comparación operativa de servidores crudos y ArduMaker
- Hostinger vs OVHcloud: cuál conviene para alojar una aplicación: Hostinger vs OVHcloud con API, PostgreSQL y tráfico real
- Hetzner vs Contabo: rendimiento, recursos y costos de VPS: Comparación Hetzner y Contabo por carga de servidor
- Cómo migrar aplicaciones Docker desde Coolify a ArduMaker: Migración Coolify a VPS ArduMaker: Compose, volúmenes, DB y HTTPS
- Cloudron vs Coolify: aplicaciones listas o desplegar código propio: Cloudron vs Coolify: autohospedar apps o desarrollar servicios
- CapRover vs Dokku: desplegar con Git o utilizar un panel: CapRover vs Dokku: flujo Git, terminal y panel
- Coolify vs Easypanel: cuál conviene para gestionar un VPS: Comparación Coolify Easypanel: permisos, Docker y costos
- Coolify vs Dokploy: diferencias para administrar aplicaciones Docker: Guía técnica y ejemplos prácticos: Coolify vs Dokploy: diferencias para administrar aplicaciones Docker. Comparación con ArduMaker.
- Cómo combinar Vercel con un backend y PostgreSQL en ArduMaker: Frontend Vercel y backend Django o FastAPI con PostgreSQL en VPS
- Cómo migrar una aplicación de Railway a un VPS sin perder datos: Migrar desde Railway a un VPS con backups, PostgreSQL y DNS
- Fly.io vs Railway: regiones, máquinas, escalado y costos: Fly.io vs Railway: disponibilidad regional, máquinas y datos
- Heroku vs Railway: diferencias en despliegue, bases de datos y workers: Heroku vs Railway con ejemplo de backend y PostgreSQL
- Vercel vs Netlify: diferencias para Next.js, Astro y páginas estáticas: Vercel o Netlify: diferencias de frontend y alternativa VPS
- Railway vs Render: cuál conviene para publicar Django, FastAPI y PostgreSQL: Análisis práctico de railway vs render: cuál conviene para publicar django, fastapi y postgresql; ejemplos, costos operativos y alternativa de VPS.
- Qué es Portainer y cómo administrar contenedores Docker desde una web: Portainer para Docker: panel visual, stacks, volúmenes y límites
- Qué es RunCloud y cómo administrar servidores PHP: RunCloud para conectar VPS y administrar PHP, Nginx y sitios web
- Qué es Cloudways y cómo funciona el hosting gestionado: Cloudways para WordPress y PHP: hosting gestionado frente a VPS
- Qué es 1Panel y cómo administrar Docker y aplicaciones web: Guía técnica y ejemplos prácticos: Qué es 1Panel y cómo administrar Docker y aplicaciones web. Comparación con ArduMaker.
- Qué es HestiaCP y cómo administrar sitios y correos en un VPS: HestiaCP para hosting y correo: instalación, límites y alternativas
- Qué es CyberPanel y cómo funciona con OpenLiteSpeed: CyberPanel y OpenLiteSpeed: sitios, caché y administración
- Qué es Plesk y cómo administrar varios sitios web: Plesk para gestionar dominios, WordPress y servidores en un panel
- Qué es cPanel y para qué sirve en un servidor de hosting: Guía técnica y ejemplos prácticos: Qué es cPanel y para qué sirve en un servidor de hosting. Comparación con ArduMaker.
- Qué es AWS Lightsail y en qué se diferencia de Amazon EC2: AWS Lightsail frente a EC2: un VPS simple o infraestructura a medida
- Qué es Scaleway y qué servicios ofrece para desarrolladores: Scaleway: instancias, almacenamiento y servicios cloud con ejemplo web
- Qué es Linode (Akamai Cloud) y para qué sirve: Linode y Akamai Cloud: VPS, desarrollo web y operación
- Qué es Vultr y cómo funcionan sus servidores Cloud Compute: Vultr Cloud Compute, instancias, regiones y escenarios prácticos
- Qué es DigitalOcean y cómo publicar una aplicación en un Droplet: DigitalOcean Droplets, SSH, firewall y despliegue web para desarrolladores
- Qué es Kamatera Cloud y cómo configurar un servidor a medida: Guía técnica y ejemplos prácticos: Qué es Kamatera Cloud y cómo configurar un servidor a medida. Comparación con ArduMaker.
- Qué es OVHcloud y cómo utilizar un VPS para publicar aplicaciones: Análisis práctico de qué es ovhcloud y cómo utilizar un vps para publicar aplicaciones; ejemplos, costos operativos y alternativa de VPS.
- Qué es Contabo y para qué tipo de proyectos convienen sus VPS: Guía técnica y ejemplos prácticos: Qué es Contabo y para qué tipo de proyectos convienen sus VPS. Comparación con ArduMaker.
- Qué es Hostinger VPS y qué incluye para alojar aplicaciones: Guía de VPS Hostinger: configuración, recursos, acceso y comparación
- Qué es Hetzner Cloud y cómo utilizar sus servidores VPS: Servidores Hetzner, SSH, firewalls y lo que cambia al usar ArduMaker
- Qué es Cloudron y cómo instalar aplicaciones autohospedadas: Cloudron y catálogo de apps autoalojadas: actualizaciones, backups y límites
- Qué es Dokku y cómo desplegar una aplicación con Git Push: Dokku como PaaS autoalojado: comandos, despliegue, plugins y ejemplos
- Qué es CapRover y cómo crear tu propio servidor de aplicaciones: Guía práctica sobre qué es caprover y cómo crear tu propio servidor de aplicaciones con ejemplos y comparativa de infraestructura.
- Qué es Dokploy y cómo desplegar proyectos utilizando Docker: Guía técnica y ejemplos prácticos: Qué es Dokploy y cómo desplegar proyectos utilizando Docker. Comparación con ArduMaker.
- Qué es Easypanel y cómo simplifica la administración de aplicaciones Docker: Cómo funciona Easypanel para apps, dominios, bases y su comparación con ArduMaker
- Qué es Coolify y cómo publicar aplicaciones en tu propio servidor: Qué instala Coolify, cómo despliega Docker y cuándo conviene un VPS con panel incluido
- Qué es Fly.io y cómo funciona el despliegue de aplicaciones por regiones: Fly.io y sus máquinas distribuidas: latencia, datos, región y comparación con VPS
- Qué es Netlify y para qué tipo de páginas web conviene: Netlify para páginas estáticas, deploy previews y funciones; cuándo utilizar ArduMaker
- Qué es Heroku, cómo funcionan los dynos y para qué sirve: Guía práctica sobre qué es heroku, cómo funcionan los dynos y para qué sirve con ejemplos y comparativa de infraestructura.
- Cómo publicar una API FastAPI en Render paso a paso: Publicar FastAPI en Render con Git, variables, salud del servicio y alternativa VPS con ArduMaker
- Cómo desplegar Next.js en Vercel: ventajas, límites y alternativas: Guía práctica sobre cómo desplegar next.js en vercel: ventajas, límites y alternativas con ejemplos y comparativa de infraestructura.
- Cómo desplegar Django y PostgreSQL en Railway: guía práctica: Una guía humana para publicar Django con PostgreSQL en Railway, revisar los fallos habituales y entender cómo hacerlo también en un VPS con ArduMaker.
- ¿Qué es un índice SQL y cuándo acelera una consulta?: Índices de bases de datos explicados: búsquedas, EXPLAIN, escrituras y errores al indexar todo.
- ¿Qué es el pooling de conexiones y por qué una base de datos se satura?: Pooling de conexiones explicado: cómo reutilizar conexiones, límites, colas y PgBouncer.
- ¿Qué es una migración de base de datos y cómo aplicarla sin perder información?: Migraciones de esquema: columnas, índices, cambios compatibles, backups y vuelta atrás.
- ¿Qué es un feature flag y cómo activar funciones sin volver a desplegar?: Feature flags explicadas con ejemplos: lanzamientos graduales, pruebas y deuda técnica.
- ¿Qué es un despliegue sin downtime y cómo evitar cortes al actualizar una web?: Despliegues sin interrupciones: health checks, balanceadores, versiones compatibles y rollbacks.
- ¿Qué es el OOM Killer de Linux y por qué cierra procesos?: Cómo reacciona Linux cuando falta memoria, qué hace el OOM Killer y cómo diagnosticar una app que desaparece.
- ¿Qué es SLAAC y cómo obtiene una dirección IPv6 tu computadora?: SLAAC explicado: autoconfiguración IPv6, anuncios de router, DHCPv6 y privacidad de direcciones.
- ¿Qué es DNSSEC y qué ataques puede ayudar a evitar?: DNSSEC explicado: firmas DNS, validación de respuestas, cadena de confianza y limitaciones frente a HTTPS.
- FTP vs SFTP: diferencias y cómo transferir archivos de forma segura: Qué diferencia hay entre FTP, FTPS y SFTP, cómo viajan los archivos y qué elegir para un servidor Linux.
- ¿Qué es HSTS y por qué protege las conexiones HTTPS?: HSTS explicado: cómo obliga al navegador a usar HTTPS, riesgos de configuración y cuándo conviene activar preload.
- Qué es WebAssembly y para qué sirve dentro de un navegador: WebAssembly desde cero: módulos binarios, JavaScript, rendimiento, casos reales y limitaciones.
- Cookies, localStorage y sessionStorage: qué guardar en cada uno: Diferencias entre cookies y almacenamiento web, expiración, seguridad, sesiones, XSS y CSRF explicados.
- Qué significan los errores HTTP 400, 401, 403, 404, 429 y 500: Guía práctica de códigos de respuesta HTTP para saber qué falla entre navegador, API, autenticación y servidor.
- ¿Qué es uptime monitoring y por qué una web puede estar caída aunque el servidor siga encendido?: Monitoreo de disponibilidad: comprobaciones HTTP, latencia, alertas, zonas y falsos positivos explicados.
- ¿Qué es Grafana y cómo crear paneles que sirvan para investigar problemas?: Grafana explicado: fuentes de datos, dashboards, alertas y errores al visualizar métricas sin contexto.
- ¿Qué es Prometheus y cómo monitorea servidores y aplicaciones?: Prometheus explicado con métricas, exporters, scraping, etiquetas, alertas y errores de cardinalidad.
- ¿Qué es OpenTelemetry y cómo ayuda a encontrar errores entre servicios?: OpenTelemetry explicado con ejemplos: traces, spans, métricas, contexto distribuido y límites de instrumentación.
- ¿Qué es observabilidad y en qué se diferencian logs, métricas y trazas?: Observabilidad explicada: qué cuentan logs, métricas y trazas, cómo investigar errores y cuándo conviene combinarlas.
- ¿Qué es un honeypot y para qué sirve en ciberseguridad?: Qué es un honeypot, cómo ayuda a observar intentos de ataque, qué límites tiene y por qué debe estar aislado.
- ¿Qué es una escalada de privilegios y cómo se evita en Linux?: Escalada de privilegios explicada de forma defensiva: permisos, servicios, actualizaciones y auditoría de accesos.
- ¿Qué es una CVE y cómo interpretar una puntuación CVSS?: Qué identifica una CVE, qué evalúa CVSS, por qué gravedad no significa riesgo inmediato y cómo priorizar actualizaciones.
- ¿Qué es un ataque man-in-the-middle y cómo puede interceptar conexiones?: Ataques de intermediario explicados: redes inseguras, TLS, certificados, advertencias del navegador y medidas de protección.
- ¿Qué es un WAF y qué diferencia tiene con un firewall normal?: Qué es un firewall de aplicaciones web, cómo filtra peticiones HTTP, falsos positivos y por qué no reemplaza corregir vulnerabilidades.
- SSR vs SSG: cuándo generar una página en el servidor o al construirla: Qué son SSR y SSG, diferencias en rendimiento, SEO, personalización, caché y cuándo elegir cada estrategia.
- ¿Qué es CSRF y cómo se protege una aplicación de solicitudes falsificadas?: Ataques CSRF explicados con cookies, acciones involuntarias, tokens anti-CSRF, SameSite y defensas del servidor.
- ¿Qué es un JWT y por qué no deberías guardar secretos dentro?: JWT explicado desde cero: header, payload y firma, diferencias con cifrado, expiración y precauciones de seguridad.
- ¿Qué es OAuth 2.0 y cómo conecta aplicaciones sin compartir contraseñas?: OAuth 2.0 explicado con un ejemplo de permisos delegados, scopes, redirecciones y diferencias entre autorización e identidad.
- Autenticación vs autorización: qué cambia entre iniciar sesión y tener permisos: Autenticación confirma quién sos y autorización decide a qué podés acceder: ejemplos, fallos y formas de probar permisos.
- ¿Qué es rate limiting y cómo proteger una API de solicitudes excesivas?: Qué es rate limiting, límites por usuario e IP, respuestas 429, ventanas temporales y cuándo puede perjudicar usuarios legítimos.
- ¿Qué es la paginación de una API y por qué evita respuestas enormes?: Paginación de APIs con limit/offset y cursores: cómo devolver listas grandes, manejar cambios de datos y evitar errores de rendimiento.
- ¿Qué es CORS y por qué el navegador bloquea una petición a tu API?: Qué es CORS, cómo funciona el preflight OPTIONS, diferencia con autenticación y cómo configurarlo sin permitir cualquier origen.
- ¿Qué es Git rebase y cuándo conviene usarlo en vez de merge?: Rebase de Git explicado con ejemplos: historia lineal, cambios de identificador, diferencias con merge y cómo evitar reescribir ramas compartidas.
- ¿Qué es un conflicto de merge en Git y cómo resolverlo sin perder cambios?: Cómo aparecen los conflictos de Git, qué significan los marcadores de conflicto y cómo resolverlos con pruebas y sin descartar trabajo.
- ¿Qué es un commit en Git y qué información guarda realmente?: Qué hace un commit de Git, por qué tiene identificador, cómo escribir mensajes útiles y qué errores evitar al guardar cambios.
- ¿Qué es una cola de trabajos y por qué tu aplicación necesita una?: Qué es una cola de tareas, cómo trabajan los workers, reintentos, idempotencia y qué hacer con trabajos fallidos.
- ¿Qué es PocketBase y por qué usa SQLite para crear un backend pequeño?: PocketBase explicado desde cero: SQLite, autenticación, API en tiempo real, límites y casos de uso.
- ¿Qué es Appwrite y qué ofrece como backend listo para usar?: Qué es Appwrite, para qué sirven autenticación, bases de datos, almacenamiento y funciones, y cuándo conviene autoalojarlo.
- ¿Qué es una herramienta MCP y cómo puede una IA ejecutar acciones reales?: Qué ofrece una herramienta MCP, cómo se diferencia de una API, qué permisos necesita y por qué la IA no debe tener acceso ilimitado.
- ¿Qué es una base de datos vectorial y para qué sirve en inteligencia artificial?: Bases vectoriales explicadas con ejemplos: embeddings, búsqueda semántica, RAG y límites frente a SQL.
- ¿Qué es una caché y por qué puede acelerar tanto una aplicación?: Qué es una caché, cómo funcionan hits, misses, TTL e invalidación y cuándo ayuda de verdad a una web.
- Hosting compartido, VPS o dedicado: diferencias y cómo elegir: Hosting compartido, VPS y servidor dedicado: control, mantenimiento, recursos y costes explicados con casos prácticos.
- ¿Qué es Railway y para qué tipo de proyectos sirve?: Railway explicado con ejemplos: desplegar apps desde Git, variables, servicios, bases de datos y diferencias con un VPS.
- ¿Qué es Render y cuándo conviene para alojar una aplicación?: Qué hace Render, cómo funciona el despliegue de aplicaciones y bases de datos desde Git y qué conviene comparar con un VPS.
- ¿Qué es una API REST y qué significan GET, POST, PUT y DELETE?: API REST explicada con ejemplos de clientes y productos: recursos, métodos HTTP, códigos de estado y diferencias con una API cualquiera.
- ¿Qué es Supabase Auth y cómo funcionan sus usuarios y sesiones?: Supabase Auth explicado: login, registro, JWT, sesiones, refresh token, recuperación de cuenta y relación con las políticas RLS.
- ¿Qué es Row Level Security (RLS) y cómo protege cada fila de PostgreSQL?: RLS explicado con un ejemplo de pedidos y usuarios: políticas por fila, permisos SQL, auth.uid(), service role y errores de seguridad frecuentes.
- ¿Qué es un thread o hilo y en qué se diferencia de un proceso?: Hilos y procesos explicados con ejemplos: memoria compartida, concurrencia, paralelismo, bloqueos y cuándo conviene usar cada uno.
- ¿Qué es un proceso en Linux y por qué aparecen tantos en un servidor?: Procesos de Linux explicados: PID, CPU, memoria, ps, top, señales y diferencia entre un proceso y un programa.
- ¿Qué es una variable de entorno y para qué sirve en un servidor?: Variables de entorno explicadas: PATH, PORT, claves de API, archivos .env, seguridad y configuración de aplicaciones en producción.
- ¿Qué es APT y cómo instalar y actualizar programas en Ubuntu?: APT en Ubuntu y Debian explicado: apt update, install, upgrade, repositorios, dependencias y consejos para actualizar servidores sin errores.
- ¿Qué es PowerShell y para qué sirve en Windows y servidores?: PowerShell explicado: cmdlets, objetos, tuberías, scripts, administración de Windows y diferencias con CMD y Bash.
- ¿Qué es Bash y en qué se diferencia de la terminal de Linux?: Bash explicado desde cero: shell, terminal, comandos, pipes, scripts, variables y errores que conviene evitar en un servidor.
- ¿Qué es la latencia y por qué Internet puede ir lento con muchos megas?: Latencia explicada: milisegundos, ping, RTT, jitter, pérdida de paquetes, ancho de banda y consejos para medir una conexión.
- ¿Qué es un switch de red y en qué se diferencia de un router?: Switch Ethernet explicado: cómo conecta equipos en una LAN, direcciones MAC, switches gestionables, VLAN y cuándo necesitas uno.
- ¿Qué es un router y qué hace cuando entrás a Internet?: Qué es un router, cómo decide las rutas de los paquetes, diferencias con Wi-Fi, módem y switch y cómo diagnosticar una conexión.
- ¿Qué es una vulnerabilidad zero-day y por qué puede ser peligrosa?: Vulnerabilidades zero-day explicadas: descubrimiento, explotación, parches, diferencia con CVE y cómo proteger sistemas sin una corrección disponible.
- ¿Qué es un ataque de fuerza bruta y cómo proteger tus contraseñas?: Fuerza bruta, password spraying y credential stuffing: diferencias, defensas con MFA, límites de intentos y seguridad de inicios de sesión.
- ¿Qué es ransomware y cómo proteger tus archivos y servidores?: Ransomware explicado desde cero: secuestro de archivos, robo de datos, copias de seguridad, señales y qué hacer ante un incidente.
- ¿Qué es CRUD y por qué aparece en casi todas las aplicaciones?: CRUD explicado con ejemplos cotidianos: crear, leer, actualizar y eliminar datos, relación con APIs REST, permisos y errores habituales.
- ¿Qué es un agente de IA y en qué se diferencia de un chatbot?: Agentes de inteligencia artificial explicados: modelos, herramientas, permisos, planificación, ejemplos y límites frente a un chatbot tradicional.
- ¿Qué es un test automatizado y cómo evitar que un cambio rompa tu web?: Pruebas automatizadas explicadas: tests unitarios, integración y end-to-end, ejemplos con Python, cobertura y errores comunes.
- ¿Qué es GitHub Actions y cómo automatiza pruebas y despliegues?: GitHub Actions explicado: workflows, eventos, jobs, runners, secrets y un ejemplo de pruebas antes de publicar código.
- ¿Qué es serverless y por qué sigue habiendo servidores detrás?: Serverless explicado: qué son las funciones bajo demanda, cuándo se ejecutan, límites, cold starts, costos y diferencias con un VPS.
- ¿Qué es un balanceador de carga y cuándo necesita uno tu web?: Load balancer explicado con ejemplos: cómo distribuye solicitudes entre servidores, diferencia entre balanceo y failover, health checks y sesiones.
- ¿Qué es XSS y cómo impedir que se ejecute código en tu página web?: Cross-Site Scripting explicado: diferencias entre texto y código, casos en comentarios y formularios, escape por contexto y sanitización segura.
- ¿Qué es una inyección SQL y cómo evitarla al crear una web?: SQL injection explicada para principiantes: qué ocurre al mezclar consultas y datos, por qué funcionan las consultas parametrizadas y cómo reducir riesgos.
- ¿Qué es TLS y qué protege realmente el candado HTTPS?: TLS explicado sin misterio: cómo HTTPS protege datos en tránsito, certificados, claves, autenticación y qué significa —y qué no— el candado del navegador.
- ¿Qué es la autenticación de dos factores y por qué protege tus cuentas?: 2FA y MFA explicados: códigos TOTP, SMS, passkeys, claves físicas, recuperación y qué métodos resisten mejor el phishing.
- ¿Qué es un worker y por qué las aplicaciones usan tareas en segundo plano?: Workers explicados con ejemplos: colas, Celery, correos, PDFs, trabajos demorados, reintentos e idempotencia sin bloquear una web.
- ¿Qué es RAG y cómo puede una IA responder usando tus documentos?: RAG explicado con ejemplos: cómo una IA busca información en documentos, qué son embeddings, por qué cita fuentes y dónde puede equivocarse.
- ¿Qué es un pull request en GitHub y para qué sirve revisarlo?: Qué es un pull request, cómo proponer cambios, revisar diferencias, ejecutar pruebas y hacer merge sin perder el control del proyecto.
- ¿Qué es JSON y por qué aparece en casi todas las APIs?: JSON explicado para principiantes: objetos, listas, cadenas, números, ejemplo real de una API y errores que impiden leerlo correctamente.
- ¿Qué es Redis y para qué sirve? Caché, sesiones y colas explicadas: Redis explicado desde cero: qué guarda en memoria, cuándo usarlo para caché, sesiones o colas y por qué no reemplaza automáticamente a PostgreSQL.
- ¿Qué es una subred y qué significa una máscara como 255.255.255.0?: Subredes y máscaras CIDR explicadas desde cero: qué significa /24, cómo se separan redes y cómo evitar errores al configurar servidores.
- ¿Qué es NAT y por qué varios dispositivos comparten una IP pública?: NAT explicado con ejemplos: IP pública y privada, traducción de puertos, conexiones salientes, port forwarding y limitaciones de CGNAT.
- ¿Qué es DHCP y por qué tu computadora recibe una IP automáticamente?: DHCP explicado sin tecnicismos: cómo el router asigna IP, máscara, puerta de enlace y DNS, qué es una concesión y cómo resolver fallos de conexión.
- Qué es un firewall y cómo proteger los puertos de un servidor Linux: Aprendé qué filtra un firewall, cómo usar UFW sin perder el acceso SSH y por qué abrir solo los puertos necesarios reduce riesgos.
- TCP vs UDP: diferencias, ejemplos y cuándo usar cada protocolo: TCP entrega un flujo fiable y ordenado; UDP envía datagramas sin esas garantías. Entendé la diferencia con ejemplos de web, juegos, DNS y QUIC.
- Qué es una CDN y cuándo acelera de verdad una página web: Una CDN acerca imágenes, CSS y otros recursos a tus visitantes. Cómo funciona la caché, cuándo ayuda, cuándo no y errores que conviene evitar.
- Qué es un bootloader y cómo arranca Linux: GRUB explicado: Bootloader en Linux: qué hace GRUB, cómo intervienen UEFI y el kernel, qué revisar si el equipo no inicia y errores habituales.
- BIOS vs UEFI: qué son y qué pasa cuando encendés la computadora: BIOS y UEFI explicados: cómo arranca una PC, diferencias, Secure Boot, discos GPT y problemas habituales al instalar un sistema.
- Debian vs Ubuntu: diferencias reales y cuál elegir para tu servidor: Debian o Ubuntu para un servidor: estabilidad, paquetes, soporte, seguridad y administración. Comparación con ejemplos y criterios para elegir.
- Supabase vs Firebase: diferencias y cuándo elegir cada uno: Comparación técnica y sencilla de Supabase y Firebase para elegir backend según datos, autenticación, precios y necesidades.
- ¿Para qué sirve Supabase? 6 ejemplos reales y sencillos: Casos concretos para usar Supabase: login, reservas, catálogos, archivos, paneles y funciones en tiempo real.
- ¿Qué es Firebase y para qué sirve en una aplicación?: Firebase de Google explicado desde cero: autenticación, Firestore, alojamiento y funciones, con ejemplos y limitaciones reales.
- ¿Qué es un ataque DDoS y cómo puede tumbar una página web?: Cómo funciona un ataque de denegación de servicio distribuido, qué síntomas produce y cuáles son las defensas habituales.
- ¿Cómo saber si alguien entró a tu servidor sin permiso?: Señales de intrusión en Linux, cambios sospechosos, registros que revisar y qué hacer sin destruir evidencias.
- ¿Qué es un ataque de cadena de suministro de software?: Cómo se puede comprometer una aplicación a través de paquetes, dependencias o proveedores de confianza y cómo reducir el riesgo.
- ¿Qué es phishing y por qué seguimos cayendo en mensajes falsos?: Cómo funcionan los intentos de phishing, ejemplos habituales y consejos prácticos para reconocerlos sin depender solo del candado HTTPS.
- ¿Qué es Nmap y cómo revisar los puertos de tu propia red?: Qué hace Nmap, cómo interpretar puertos abiertos, cerrados y filtrados, y cómo realizar una comprobación sencilla en una red autorizada.
- ¿Qué es Kali Linux y cuándo conviene utilizarlo?: Qué es Kali Linux, para qué sirven sus herramientas de auditoría y cuándo no conviene usarlo como sistema de uso diario.
- ¿Qué es una API y para qué sirve en una aplicación?: Qué es una API, cómo se comunican frontend y backend, ejemplos cotidianos y diferencias entre una API y una página web.
- ¿Qué es Vercel y para qué tipo de proyecto conviene?: Qué hace Vercel, cómo publica aplicaciones desde Git, qué son los previews y cuándo resulta mejor usar un VPS.
- ¿Qué es CI/CD y por qué automatizar los despliegues?: Integración continua, entrega y despliegue continuo explicados con ejemplos: qué automatizar, qué probar y cómo evitar publicar errores.
- ¿Qué es localhost y por qué se usa 127.0.0.1?: Entendé localhost, 127.0.0.1, puertos locales y por qué una aplicación puede funcionar en tu PC pero no ser accesible desde Internet.
- ¿Qué es un VPS y para qué sirve realmente?: Qué es un servidor privado virtual, cómo funciona, ejemplos reales, diferencias con un hosting y cuándo vale la pena alquilar uno.
- ¿Qué es un servidor y por qué no es tan distinto de una PC?: Un servidor es una computadora o programa que ofrece información o funciones a otros equipos. Una explicación sencilla con un ejemplo visual, cuándo sirve y qué conviene tener en cuenta.
- Windows, macOS o Linux: ¿cuál conviene usar y para qué?: No existe un sistema operativo que sea la mejor elección para todas las personas. Una explicación sencilla con un ejemplo visual, cuándo sirve y qué conviene tener en cuenta.
- ¿Qué es Ubuntu y por qué se usa tanto en servidores?: Ubuntu es una distribución Linux: reúne el kernel, herramientas, programas y un método de actualización. Una explicación sencilla con un ejemplo visual, cuándo sirve y qué conviene tener en cuenta.
- ¿Qué es un kernel y por qué tu computadora lo necesita?: Qué hace el kernel de Linux, cómo conecta programas y hardware, y por qué importa aunque nunca lo veas. Explicación sencilla y ejemplo.
- Cómo organizar proyectos, empresas y equipos dentro de ArduMaker: La estructura de la plataforma explicada de una vez: qué es una Empresa, qué es un Proyecto, cómo se reparten los permisos y por qué esa separación resuelve problemas que después son carísimos.
- Para quién está pensada la nube de ArduMaker: Tres perfiles donde encaja bien, dos donde no, y la pregunta honesta que conviene hacerse antes de mover infraestructura.
- Por qué usar la nube de ArduMaker: No competimos en cantidad de servicios ni en precio por gigabyte. Lo que resolvemos es otra cosa: que un equipo chico pueda operar infraestructura de varios clientes sin que se le vuelva un trabajo aparte.
- Qué es AWS y por qué se volvió el nombre de la nube: De un experimento interno de una tienda de libros a la infraestructura de medio internet. Qué vende realmente, por qué su factura sorprende, y cuándo conviene y cuándo no.
- Por qué existen tantos lenguajes de programación: Cada uno optimiza algo distinto y lo paga en otro lado. Compilado o interpretado, tipado o no, con recolector de basura o sin él: los tres ejes que explican casi todas las diferencias.
- Monolito o microservicios: cómo elegir sin arrepentirse: Cinco preguntas que deciden mejor que cualquier diagrama, por qué la arquitectura correcta depende de tu equipo y no de tu tecnología, y cómo dejar la puerta abierta a cambiar.
- Qué son los microservicios y por qué aparecieron: No nacieron por una razón técnica sino organizativa. Qué problema resuelven de verdad, qué costos traen y por qué el monolito modular es la respuesta correcta para la mayoría.
- Quién decide que un dominio es tuyo: No hay una autoridad mundial que diga quién es dueño de qué: hay una cadena de delegación y una base de datos. Cómo funciona, quién la sostiene y qué pasa cuando hay una disputa.
- Cómo se crea un dominio y qué pasa después de comprarlo: Registrador, registro y nameservers: quién es quién. Los cinco pasos desde el registro hasta el sitio funcionando, y las trampas de renovación, privacidad y transferencia.
- Qué es un dominio y qué pasa cuando alguien lo escribe: Se lee al revés de como se escribe, y esa sola idea explica toda la jerarquía. El recorrido completo de la consulta DNS, qué es el TTL y por qué los cambios tardan.
- Los pasos para encontrar una falla en un servidor: Un método en seis pasos que evita el diagnóstico a ciegas: qué preguntar primero, en qué orden mirar, cómo descartar de a una y por qué el reinicio va al final.
- Cómo y dónde se guardan los logs en un servidor: Dónde busca cada cosa, qué cambió con journald, por qué un log sin rotación llena el disco, y los comandos que resuelven la mayoría de las búsquedas.
- Qué es un file descriptor y por qué todo en Linux es un archivo: Un número entero que representa cualquier cosa abierta: archivos, sockets, tuberías, el teclado. Por qué esa abstracción hizo tan potente a Unix, y qué significa "too many open files".
- Cómo se gestionan los procesos hijos en Linux: Qué hacen fork y exec, por qué existen los procesos zombis y qué significan realmente, quién adopta a los huérfanos, y por qué tu contenedor ignora la señal de apagado.
- Qué es el PATH y por qué "command not found" casi nunca es lo que parece: Una lista de carpetas separadas por dos puntos que decide qué programa se ejecuta. Cómo se busca, por qué el orden importa tanto, y los tres casos donde falla.
- Cómo se compila un binario, de código a proceso: Las cuatro etapas que convierten texto en un programa, qué hace el enlazador y por qué falla tanto, la diferencia entre enlazado estático y dinámico, y qué pasa al ejecutarlo.
- Cómo se mide el trabajo de un servidor sin volverse loco: Cuatro números que dicen casi todo, qué significa realmente el load average, por qué el uso de CPU engaña, y en qué orden mirar cuando algo va lento.
- HDD, SSD y NVMe: la diferencia que sí se nota: Por qué el salto de disco mecánico a SSD fue el mayor de la historia reciente, qué agrega NVMe encima, y por qué las operaciones por segundo importan más que los megabytes por segundo.
- RAM: qué cambia de verdad entre DDR3, DDR4 y DDR5: Frecuencia, latencia y ancho de banda explicados sin marketing. Por qué más megahercios no siempre es más rápido, y por qué en un servidor la cantidad casi siempre gana.
- Qué mide un CPU score y por qué dos servidores iguales no rinden igual: De dónde sale ese número, qué mide y qué ignora, por qué un solo hilo puede importar más que dieciséis, y cómo medir lo que de verdad afecta a tu aplicación.
- Qué es un vCPU y qué estás comprando realmente: Un vCPU no es un procesador: es un turno sobre uno real. Qué significa dedicado o compartido, por qué dos planes con el mismo número rinden distinto, y cómo medirlo vos mismo.
- Docker: cuándo usarlo y cuándo te complica la vida: Qué problema resuelve de verdad, los cuatro casos donde suma sin discusión, los tres donde es peso muerto, y los errores que convierten una buena idea en un dolor de cabeza.
- Cómo hace Ubuntu para virtualizar: KVM, namespaces y cgroups: Las tres piezas que trae el kernel de Linux y que sostienen casi toda la infraestructura moderna. Qué hace cada una, cómo se combinan y qué comandos te dejan verlas funcionando.
- Qué es LXC y en qué se diferencia de Docker y de una VM: Contenedores de sistema en vez de contenedores de aplicación. Qué significa eso en la práctica, por qué muchos proveedores de VPS lo usan, y cómo saber en cuál de los dos estás.
- Para qué se usa la virtualización en la vida real: Más allá de "aprovechar el hardware": aislar clientes, poder destruir sin miedo, reproducir un entorno, mover máquinas sin apagarlas y recuperarse rápido. Cinco usos concretos.
- Qué es la virtualización, explicada desde cero: Cómo una máquina física se convierte en varias independientes, qué hace un hipervisor, la diferencia real entre una VM y un contenedor, y por qué todo el cómputo en la nube depende de esto.
- Cómo creció Internet: de 4 nodos a todo el planeta: Qué decisión de diseño permitió que escalara sin que nadie la coordinara, por qué TCP/IP le ganó a alternativas mejor financiadas, y qué se rompió por el camino.
- Cómo se pasaban archivos antes de Internet: Disquetes en la mano, módems que ocupaban la línea del teléfono, BBS y UUCP. No es nostalgia: varias ideas de esa época siguen vivas en las herramientas que usás hoy.
- Cómo se mueven archivos grandes por la red sin sufrir: Por qué copiar 200 GB con el método equivocado tarda el triple, qué hace rsync que scp no puede, y cómo diagnosticar si el cuello está en el disco, la red o la CPU.
- Cómo se hacen las copias de seguridad por dentro: Qué es un backup en caliente, por qué un volcado y una copia física resuelven problemas distintos, cómo funciona la deduplicación y para qué sirve verificar con hash.
- Qué es realmente una copia de seguridad: Un archivo guardado no es un backup: lo es un procedimiento probado de recuperación. La regla 3-2-1, las dos preguntas que definen tu estrategia, y por qué un snapshot no siempre alcanza.
- Cómo se compromete una base de datos (y cómo se evita): Los cinco caminos reales por los que se filtran datos, en orden de frecuencia. Ninguno implica romper el cifrado, y casi todos se cierran con decisiones que ya conocés.
- Qué es Supabase y cómo tener tu propia base gestionada en ArduMaker: Postgres con API automática, autenticación y almacenamiento encima. Qué resuelve de verdad, qué significa que sea open source, y cuándo conviene armarlo vos mismo.
- Por qué existen tantos tipos de bases de datos: No es moda: cada familia optimiza algo distinto y paga por ello en otro lado. Relacionales, documentos, clave-valor, columnares, grafos y series temporales, con el caso donde cada una gana.
- Cómo publicar y conectarte a Postgres sin dejarlo expuesto: Las cuatro formas de llegar a tu base de datos, ordenadas de peor a mejor, y por qué abrir el puerto 5432 a Internet es casi siempre la respuesta equivocada.
- Qué es PostgreSQL y por qué se volvió el default: De proyecto universitario a la base relacional que casi todo el mundo elige. Qué la hizo ganar, qué trae de fábrica que sorprende, y los dos ajustes que casi nadie toca y debería.
- Por qué n8n es gratis y de pago al mismo tiempo: No es open source en el sentido estricto: es "fair-code". Qué permite y qué no la licencia sustainable use, por qué se inventó esa categoría y qué significa en la práctica para tu empresa.
- Qué es n8n y qué problema resuelve: Conectar servicios que no se hablan entre sí, sin escribir un script para cada combinación. Cómo funciona un flujo de nodos, cuándo conviene y cuándo es mejor código.
- Webhook, WebSocket o consulta periódica: cuál usar en cada caso: Tres formas de enterarse de que algo pasó, con costos muy distintos. Cuatro preguntas que resuelven la decisión sin discutir arquitectura.
- Qué es un WebSocket y cuándo lo necesitás de verdad: Una conexión que queda abierta en las dos direcciones. Cómo empieza siendo HTTP y deja de serlo, qué cuesta mantenerla, y por qué muchas veces alcanza con algo más simple.
- Qué es un webhook y por qué está en todas partes: En lugar de preguntar cada cinco minutos, el otro servicio te avisa. Cómo funciona, por qué siempre hay que verificar la firma, y los tres detalles que rompen integraciones en producción.
- Los roles de una empresa de software, explicados sin vueltas: Qué hace realmente cada uno, por qué los títulos varían tanto entre empresas, y qué pasa cuando un rol no existe: el trabajo no desaparece, lo absorbe alguien peor preparado.
- De git push a producción: el camino completo, paso a paso: Qué pasa exactamente entre que subís un commit y tu sitio se actualiza, cuáles son los tres puntos donde se rompe, y cómo leer los logs para saber cuál fue.
- Qué ramas necesitás de verdad en un proyecto real: Los flujos de trabajo famosos resuelven problemas que quizá no tenés. Tres modelos, para qué sirve cada uno, y cómo elegir según cómo publicás y cuántos son.
- Por qué existen las ramas y los merge: Una rama es un puntero de 41 bytes, y eso explica por qué Git cambió la forma de trabajar en equipo. Qué es realmente un conflicto, y la diferencia entre merge y rebase sin religión.
- Qué es un repositorio remoto y por qué existe: Un remoto no es "la nube": es otra copia del repositorio a la que le pusiste un nombre. Qué hacen fetch, pull y push en realidad, y por qué conviene separar traer de integrar.
- Git y GitHub no son lo mismo: qué hace cada uno: Uno es un programa que corre en tu máquina; el otro es un servicio con una copia de tu repositorio y un montón de cosas alrededor. Dónde termina uno y empieza el otro, y por qué importa.
- Cómo funciona Git por dentro (y por qué eso te ahorra sustos): Git no guarda diferencias: guarda fotos completas. Entender eso explica por qué las ramas son baratas, por qué casi nada se pierde de verdad y qué hace realmente cada comando.
- Por qué el .env importa tanto y cómo tratarlo bien: Las claves que más se filtran no se roban: se suben sin querer. Tres costumbres que evitan casi todos esos sustos, y qué hacer cuando una credencial ya estuvo en un commit.
- Cómo manejar ambientes: desarrollo, staging y producción: Para qué sirve cada uno, qué tienen que compartir y qué nunca, cómo tener staging sin pagar un segundo servidor, y el error con los datos que se comete siempre.
- Por qué el deploy es la parte más importante de tu proyecto: El código que no está en producción no existe. Por qué un despliegue difícil deforma todo lo demás, qué significa que sea aburrido y cómo se llega ahí.
- Qué es Django y por qué sigue siendo una gran decisión: Un framework que trae todo resuelto: ORM, migraciones, panel de administración y seguridad por defecto. Qué gana y qué cuesta elegirlo, y en qué casos conviene otra cosa.
- Qué es una SPA y qué gana (y pierde) tu sitio con ella: Una sola página que se reescribe sola: qué problema resuelve, por qué rompió el botón de atrás durante años, qué pasa con el SEO y cuándo conviene no usarla.
- Qué significa que algo "se compile en el cliente": La diferencia entre armar el HTML en el servidor y armarlo en el navegador, qué cambia para el usuario, para el buscador y para tu factura de servidor, y por qué hoy casi todo es una mezcla.
- Por qué existen el frontend y el backend como cosas separadas: No es una moda ni una forma de dividir tareas: son dos entornos con reglas incompatibles. Qué corre en cada lado, por qué nunca hay que confiar en el navegador y dónde va cada validación.
- Qué es una interfaz web y qué hay debajo de lo que ves: Del momento en que escribís una dirección hasta que aparece la página: DNS, TCP, TLS, HTML, CSS y JavaScript, cada uno con su trabajo. Y por qué esa cadena explica casi todos los problemas de rendimiento.
- Cómo mantenemos seguros los servidores de ArduMaker, día a día: La parte operativa, no la de diseño: qué se actualiza, qué se vigila, cómo se aíslan las cosas y qué pasa cuando algo se cae a las tres de la mañana.
- Por qué se dice que Internet no es seguro: Internet se diseñó para que los paquetes lleguen, no para que nadie los lea. Qué significa eso en la práctica, qué arregló HTTPS, qué sigue siendo visible y por qué el eslabón débil casi nunca es el cifrado.
- Una clave SSH por persona: el detalle que cambia todo cuando sos equipo: Por qué compartir una clave privada arruina el modelo entero, cómo se agregan y quitan claves sin tocar a nadie más, y qué hacer el día que alguien pierde la laptop.
- Cómo nació SSH: la historia detrás del comando que usás todos los días: Un ataque de captura de contraseñas en Helsinki en 1995, un investigador molesto, y el protocolo que reemplazó a telnet. También por qué OpenSSH existe y qué tiene que ver OpenBSD.
- Acceso SSH que se cierra solo: por qué lo hicimos así: El problema no es abrir el acceso, es acordarse de cerrarlo. Cómo funciona un acceso con fecha de vencimiento y qué cambia en la práctica cuando pedir permiso deja de tener consecuencias permanentes.
- Qué es SSH y qué pasa exactamente cuando te conectás: El par de claves explicado sin misterio, qué es el desafío que firma tu máquina, por qué el servidor puede tener tu clave pública sin riesgo y qué significa ese aviso gigante de host changed.
- Qué es Tailscale y por qué cambió la forma de conectar máquinas: Una VPN sin servidor central por el que pase el tráfico: cómo funciona el modelo de malla sobre WireGuard, qué resuelve que una VPN clásica no, y cuándo no conviene.
- Cómo funciona una VPN, de verdad: Qué hace realmente un túnel cifrado, qué esconde y qué no, por qué "VPN = privacidad" es marketing, y para qué sirve de verdad en un equipo técnico.
- Un servidor, muchos dominios: cómo se reparte el tráfico: Cómo un solo servidor con una sola dirección atiende diez sitios distintos, qué es SNI, por qué el primer bloque de nginx es especial y cómo evitar que un dominio sirva el sitio de otro.
- Qué es nginx y por qué está delante de casi todo: Un proxy inverso explicado sin rodeos: qué resuelve, por qué tu app no debería hablar con Internet directamente, y los tres errores que dan 502, 504 y 413.
- IPv4 e IPv6: por qué convivimos con dos Internet a la vez: Se acabaron las direcciones en 2011 y sin embargo todo sigue funcionando. Qué cambió con IPv6, por qué la transición tarda tanto y qué significa para tu servidor.
- Cómo funciona realmente una dirección IP: Qué son esos cuatro números, por qué existen las direcciones privadas, qué hace la máscara de red y por qué tu paquete llega a destino sin que nadie conozca el camino completo.
- Cómo movemos tráfico entre nuestros servidores sin exponerlo a Internet: Cuando una app en un servidor necesita una base que vive en otro, hay dos caminos: abrir un puerto al mundo o hacer que se vean entre ellos. Por qué elegimos el segundo.
- Cuándo conviene una redirección de puertos y cuándo no: Una guía corta para decidir entre abrir un puerto, poner un proxy inverso o levantar un túnel, y la pregunta que resuelve el noventa por ciento de los casos.
- Redirección de puertos: qué es y qué resuelve: Qué hace realmente un reenvío de puertos, en qué se diferencia de un proxy inverso y de un túnel SSH, y cuándo cada uno es la herramienta correcta.
- Qué es un puerto y por qué tu app necesita uno: Una IP encuentra la máquina; el puerto encuentra el programa. Qué son los 65535 puertos, por qué los de abajo de 1024 son especiales y cómo se diagnostica un "address already in use".
- Cómo dar acceso a tu equipo sin repartir contraseñas: Por qué la contraseña compartida siempre termina filtrada, cómo se reparte el acceso por persona y por proyecto, y qué tiene que pasar el día que alguien se va del equipo.
- Cómo se crean los usuarios en Linux, por dentro: Qué hace realmente adduser: los cuatro archivos donde vive un usuario, para qué sirve /etc/skel y las dos trampas clásicas al crear y borrar cuentas.
- Por qué no usamos root para todo (y qué hacemos en su lugar): Trabajar como root no ahorra tiempo: quita las advertencias, rompe los dueños de los archivos y borra el rastro de quién hizo qué. Qué hace sudo realmente y cómo configurarlo bien.
- Por qué Linux es multiusuario desde su primer día: De dónde salen los permisos, los uid y la costumbre de que cada servicio tenga su propio usuario, y por qué ese diseño de hace cincuenta años sigue siendo la mejor defensa gratuita que tenés.
- Por qué los servidores no tienen escritorio (y cuándo sí conviene una interfaz): Lo que cuesta una sesión gráfica en un servidor: RAM, superficie de ataque y, sobre todo, trabajo que no se puede repetir. Y los casos donde igual conviene.
- Qué es la terminal y por qué sigue siendo la herramienta más rápida: La terminal no es difícil, es escueta. Qué es realmente, en qué se diferencia del shell, cómo leer un comando que nunca viste y las tres salidas de emergencia.
- Arquitectura segura por defecto: cómo está pensado ArduMaker: Puertos cerrados por defecto, SSH con fecha de vencimiento, aislamiento por empresa y auditoría de cada comando: por qué la seguridad que depende de la memoria siempre falla.
- Consejos para usar un servidor sin romperlo: Cinco costumbres que evitan la mayoría de los incidentes en un servidor: un cambio por vez, copias antes de editar, validar antes de recargar, dejar una sesión de rescate y documentar.
- Correo propio que no cae en spam: SPF, DKIM, DMARC y buzones explicados de verdad: Guía honesta sobre SPF, DKIM y DMARC: qué hace cada uno, por qué sin los tres tu correo termina en spam, y cómo montar un dominio de correo con buzones y verificación DNS conversando con una IA. Cubre crear_dominio_correo, verificar_dns_dominio_correo, crear_cuenta_correo, editar_cuota_cuenta_correo y ver_stats_dominio_correo.
- Publicar un dominio con HTTPS en tu VPS: nginx, certificados y el 502 de todos los días: Cómo publicar un dominio en un VPS con certificado SSL: qué hace realmente Let's Encrypt, por qué el orden de los pasos importa, cómo leer los logs de nginx para diagnosticar un 502 y cómo hacerlo todo conversando con una IA. Cubre crear_dominio_vps, verificar_dominio_vps, activar_dominio_vps, ver_nginx_dominio_vps, editar_nginx_dominio_vps y ver_logs_nginx_vps.
- DNS sin misterio: registros, nameservers y propagación, administrados por conversación: Guía práctica de DNS para desarrolladores: qué hace cada tipo de registro, por qué el TTL importa más de lo que parece, cómo funciona la propagación real y cómo administrar todo conversando con una IA mediante el MCP de ArduMaker. Incluye crear_dominio_empresa, ver_estado_ns_dominio, listar_registros_dns, crear_registro_dns y editar_registro_dns.
- Servicios systemd, tareas programadas y logs en un VPS, pedidos en lenguaje natural: Cómo crear servicios systemd, programar tareas recurrentes y leer logs en un VPS pidiéndoselo a una IA. Un ejemplo de uso real para cada herramienta del MCP de ArduMaker: crear_servicio_vps, controlar_servicio_vps, ver_logs_systemd_vps, crear_tarea_vps, ver_logs_tarea_vps y el resto del área de automatización.
- Crear y administrar un VPS hablando con una IA: guía práctica del MCP de ArduMaker: Guía práctica para crear, encender, redimensionar y administrar servidores VPS conversando con una IA a través del MCP de ArduMaker. Incluye un ejemplo de uso cotidiano para cada herramienta: crear_vps, controlar_vps, cambiar_plan_vps, ejecutar_comando_vps, ver_estado_vps, crear_usuario_vps, crear_redireccion_vps y más.
- Qué es un MCP y cómo funciona el MCP de ArduMaker: Explicación clara del Model Context Protocol (MCP): qué es, cómo funciona y por qué convierte a una IA en un operador real. Incluye un recorrido por el MCP de ArduMaker, su catálogo de cientos de herramientas para VPS, DNS, correo, bases de datos, proyectos y blogs, y un ejemplo real: este mismo artículo fue creado y publicado por una IA usando ese MCP.