Lo que aprendemos construyendo APIs, apps móviles, IA y plataformas web para PYMEs en Latinoamérica.
El streaming SSR con Suspense manda la respuesta en partes, no de una vez: cambia cuándo un error boundary puede actuar y qué puede hacer la página una vez que el shell ya salió por streaming.
Leer →Blue-green y canary resuelven el mismo problema de formas muy distintas. Vemos qué señales de un release y qué tooling instalado en el clúster deciden cuál usar en GKE.
Leer →Llevamos Kotlin Multiplatform a apps reales y aprendimos dónde compartir código ahorra trabajo y dónde termina costando más que mantener dos implementaciones nativas.
Leer →Un JSON Schema fuerza la forma de la respuesta de un LLM, no su contenido: vemos dónde ese modo estructurado deja pasar datos inventados y qué seguimos validando después.
Leer →Astro no hidrata nada por defecto, pero tampoco decide por nosotros la frontera de una isla. Vemos el caso donde hidratar la tarjeta completa en vez de un solo botón infló el bundle de un catálogo entero.
Leer →WorkManager no promete ejecutar un trabajo en el momento que pedimos, sino dentro de las reglas que Doze y App Standby le imponen al sistema. Vemos como funciona esa negociacion y que combinacion de causas retraso una sincronizacion horaria hasta cada tres o cuatro horas.
Leer →Sin NetworkPolicies, cualquier pod del clúster puede hablar con cualquier otro sin ninguna restricción. Vemos cómo construir una denegación por defecto y qué se rompió la primera vez que la aplicamos sin permitir DNS.
Leer →SnapStart congela el arranque de la JVM en una instantánea y la reutiliza en cada entorno nuevo, pero esa instantánea también congela cualquier estado que debería ser único por ejecución. Vemos qué soluciona de verdad y qué hay que corregir con runtime hooks.
Leer →El cold start de Cloud Run no es un problema universal: importa cuando hay un usuario esperando esa respuesta y casi nunca cuando el trabajo corre en segundo plano. Vemos qué controla el tiempo de arranque y qué pasó cuando pusimos instancias mínimas en el servicio equivocado.
Leer →Recalcular un embedding que no cambió sale caro apenas el tráfico crece. Vemos qué llave de caché usamos y qué se rompió la primera vez que invalidamos mal tras editar el contenido fuente.
Leer →Mover un cálculo pesado a un isolate en Flutter parece sencillo hasta que copiar el estado completo en cada mensaje sale más caro que el cálculo mismo. Vemos cómo rediseñamos el paso de datos entre isolates.
Leer →Guardar un pedido y publicar su evento como dos operaciones separadas puede desincronizarse sin que nadie lo note. Vemos cómo la tabla outbox lo evita y qué hicimos cuando el publicador en segundo plano se quedó atrás.
Leer →Probar tool calling en un notebook es trivial; exponerlo contra una API que modifica datos reales no. Vemos qué registramos por cada llamada para auditar y revertir cuando el modelo elige mal.
Leer →Una liveness probe que depende de la base de datos puede reiniciar pods sanos bajo carga. Vemos como separamos liveness de readiness y por que bajar el failureThreshold empeoro las cosas.
Leer →earliestBeginDate no es una promesa: es apenas la fecha más temprana en que iOS podría considerar tu tarea. Vemos qué decide el sistema realmente y cómo diseñamos BGTaskScheduler para no depender de una cadencia que nunca existió.
Leer →Al migrar a Server Components los errores mas dificiles no son de sintaxis: son limites "use client" mal puestos y estado que termina duplicado entre servidor y cliente. Vemos como decidimos que se queda en el servidor.
Leer →Un mensaje que falla en SQS no desaparece: vuelve a entregarse hasta bloquear la cola o agotar reintentos. Vemos cómo ajustamos visibility timeout, maxReceiveCount y el monitoreo de la DLQ para que eso no pase.
Leer →SwiftData reduce el código de persistencia en proyectos iOS nuevos, pero cede control fino sobre migraciones y múltiples configuraciones de almacenamiento que Core Data sí ofrece. Vemos en qué tipo de proyecto cambiamos y en cuál seguimos con Core Data.
Leer →Antes de proponer una migración a microservicios preguntamos por el equipo, los límites reales del dominio y el ritmo de cambio del negocio. A veces la respuesta correcta es quedarse en el monolito.
Leer →Un frontmatter sin validar falla en produccion cuando alguien visita la pagina rota. Vemos como Content Collections y un esquema Zod mueven ese error al momento del build, y por que z.coerce.date() evita el fallo mas comun con las fechas.
Leer →Crear un pedido y reservar inventario en dos servicios distintos no admite una transaccion ACID compartida. Vemos como una saga orquestada con pasos locales y compensacion reemplaza al two-phase commit, y por que la primera version coreografiada por eventos nos dejo sin visibilidad del estado.
Leer →Un chunking que corta párrafos a la mitad arruina la recuperación en pgvector aunque el modelo de embeddings sea bueno. Vemos cómo cortar por estructura del documento en vez de por caracteres, y por qué aumentar el solape empeoró la búsqueda en lugar de arreglarla.
Leer →Un token bucket en memoria funciona con un solo proceso, pero se rompe en cuanto la API escala a varias réplicas: cada una cuenta por su lado y el límite real se multiplica. Vemos cómo INCR y TTL en Redis dan un conteo atómico y compartido, y qué falló al intentarlo con GET y SET separados.
Leer →Una LazyColumn de doscientos ítems recompone entera cuando solo cambió uno. Vemos por qué las claves por posición y las lambdas inline rompen el skip de Compose, y cómo corregirlo con key, remember y derivedStateOf.
Leer →Paginar con Paging 3 y RemoteMediator sobre un offset numérico falla cuando el backend recibe inserciones mientras el usuario hace scroll. Vemos por qué un cursor basado en id resuelve el problema y qué salió mal al intentar deduplicar en el cliente.
Leer →Los standalone components declaran sus propias dependencias en el decorator, sin pasar por un NgModule contenedor. Vemos que cambia en el arbol de dependencias, en el lazy loading por ruta, y que salio mal al migrar un SharedModule completo de una sola vez.
Leer →Durable Functions persiste el estado de un flujo de aprobación de varios días mediante replay sobre una historia de eventos, sin que el desarrollador escriba una tabla de estado a mano.
Leer →Testcontainers levanta un Postgres real en Docker para los tests de integración de Spring Boot. Vemos qué problema resolvió frente a mockear el repositorio y qué cuesta en tiempo de CI.
Leer →System.Text.Json puede generar el código de serialización en tiempo de compilación en vez de resolverlo por reflection en cada arranque. Vemos cómo funciona y qué rompimos al mezclarlo con un fallback a reflection bajo Native AOT.
Leer →En Node.js, el trabajo CPU-intensivo bloquea el event loop entero aunque el handler sea async. Vemos cuándo aislarlo con worker_threads, cómo pasar datos sin copiarlos y cuándo conviene más un proceso separado.
Leer →Cambiamos un pipeline de CI que aplicaba manifiestos a mano por un controlador que sincroniza el cluster contra git y detecta drift en cada ciclo de reconciliacion.
Leer →Extraer un monolito módulo a módulo sin detener el negocio exige un enrutador que decida qué sistema atiende cada petición, y un criterio claro sobre qué extraer primero: el límite de datos, no el de carpetas del código.
Leer →Un dashboard lleno de CPU y memoria no explica por que una request especifica fue lenta. Vemos como configuramos Micrometer con OpenTelemetry en Spring Boot 3 para exportar metricas de negocio y trazas que si responden esa pregunta.
Leer →Integramos un revisor LLM en los pull requests: que tipo de hallazgos le confiamos y por que las decisiones de arquitectura quedaron fuera de su alcance.
Leer →Un cambio hecho a mano en la consola de AWS deja el state de Terraform desincronizado, y el próximo apply lo revierte sin que nadie lo note. Vemos cómo detectamos ese drift antes de que duela.
Leer →Un timeout sin circuit breaker sigue agotando threads mientras el proveedor externo sigue caído. Vemos como Resilience4j corta las llamadas a tiempo con CircuitBreaker, TimeLimiter y un bulkhead de threads dedicado.
Leer →Mezclar estado de servidor y de cliente en el mismo store de Redux obliga a sincronizar la cache a mano. Vemos como TanStack Query separa ambos mundos.
Leer →Cloud Tasks entrega a un destino único con control de tasa; Pub/Sub publica un evento para cualquier número de suscriptores. Repasamos dónde cada uno encaja mal en un backend real.
Leer →Encadenar Lambdas por eventos funciona hasta que el flujo crece: reintentos que repiten pasos ya hechos, y nadie sabe en que paso quedo un caso. Repasamos cuando conviene pasar a Step Functions.
Leer →Reemplazar completion handlers por async/await no es solo un cambio de sintaxis: es atar la vida de cada tarea al ciclo de vida de la vista. Repasamos Task, async let, TaskGroup y el bug de un Task suelto que actualizaba una pantalla que ya no existía.
Leer →DataAnnotations no expresa bien reglas condicionales ni comparaciones entre campos. Como estructuramos validadores con FluentValidation y los enganchamos al pipeline de una Minimal API en .NET.
Leer →El CPU bajo no significa poco trabajo: puede significar que el pod está esperando una respuesta externa mientras la cola crece. Cómo conectar Prometheus Adapter al HPA para escalar sobre la señal correcta.
Leer →El límite entre servidor y cliente no pasa por la pantalla completa, sino por el componente puntual que necesita interactividad. Los criterios que usamos para decidirlo.
Leer →Un timeout de red no significa que el pago falló: puede significar que el cliente perdió la respuesta de un pago que sí se procesó. Cómo implementar una clave de idempotencia en Spring Boot que cubra ese caso, no solo el cobro duplicado.
Leer →Los problemas concretos de Provider que nos llevaron a Riverpod: dependencia de BuildContext, providers implícitos difíciles de testear, y la migración completa de un provider real paso a paso.
Leer →Comparamos Cloud Run y GKE Autopilot en los puntos que de verdad cambian una decisión de arquitectura: cold starts, control de networking y el momento en que un cluster empieza a valer la pena.
Leer →SSE resuelve buena parte de las actualizaciones en tiempo real con una fracción de la complejidad de un servidor WebSockets. Comparamos dirección del flujo, reconexión automática y compatibilidad con la infraestructura HTTP existente, con ejemplos en Node.js.
Leer →Astro no hidrata nada por defecto: cada componente interactivo es una decisión explícita. Repasamos client:load, client:idle, client:visible y el error más común: hidratar componentes que nunca necesitaron JavaScript en el cliente.
Leer →Managed Identity resuelve la autenticacion entre recursos de Azure sin guardar credenciales, pero solo si se entiende la diferencia entre identidad de sistema y de usuario, y los errores de RBAC que la rodean.
Leer →Un pipeline concreto de GitHub Actions hacia ECS Fargate: build, push a ECR, task definition y despliegue rolling sin downtime, con OIDC, health checks y rollback automático.
Leer →pipe() respeta el backpressure del flujo de datos, pero no el de errores ni el de un Transform que acumula chunks por su cuenta. Repasamos por qué eso satura la memoria de un microservicio de ingesta y cómo pipeline() resuelve el ciclo de vida.
Leer →GlobalScope no tiene ciclo de vida, y eso es exactamente lo que produce el leak. Repasamos la jerarquia de Job, la diferencia real entre lifecycleScope y viewModelScope, y por que un SupervisorJob mal usado puede ocultar excepciones.
Leer →El macro @Observable de Swift cambia el seguimiento de estado a nivel de propiedad, no de objeto. Repasamos el impacto real en la recomposición de vistas y cuándo usar @State frente a @Bindable.
Leer →Minimal APIs quita ceremonia, pero no organiza el proyecto por ti. Repasamos como agrupar endpoints, donde van los filtros de validacion y el punto en el que conviene volver a controllers.
Leer →Sin readinessProbe y sin startupProbe, un pod puede aparecer sano y seguir causando 502 durante cada rolling deploy. Repasamos las tres probes, sus valores por defecto y cómo dimensionarlas para arranques lentos en JVM y .NET.
Leer →Signals no reemplaza a RxJS: resuelve otro problema. Repasamos cuando usar cada uno, como conviven con toSignal y toObservable, y los anti-patrones mas comunes al migrar codigo RxJS-heavy.
Leer →Los LLM generan métodos, imports y parámetros que suenan reales pero no existen. Repasamos las cinco señales que delatan una alucinación de código antes de que cueste horas de debugging.
Leer →Cómo estructuramos proyectos Flutter medianos y grandes por feature, con Cubit para el estado e inyección de dependencias con get_it. Con código, criterios y los errores que rompen la separación en la práctica.
Leer →Un LLM puede escribir código que compila y pasa sus propios tests sin que eso signifique que es entregable. Repasamos los cuatro filtros que aplicamos antes de que el cliente lo vea.
Leer →La mayoría de los proyectos no necesita microservicios todavía. Repasamos qué cuestan de verdad y los cinco indicadores objetivos que sí justifican dividir el monolito.
Leer →Nueve artículos contando fallos de nuestro propio producto. No es humildad: es la única forma de que un número bueno signifique algo.
Leer →Ningún test cubre el escenario en que tu programa no se está ejecutando. Y ese resultó ser uno de nuestros modos de fallo más caros.
Leer →Si la forma de Cerberus es lo que pierde dinero, un sistema con la forma contraria debería ganarlo. Lo construimos. El resultado fue un factor de 1,04 en siete años y medio: una moneda al aire.
Leer →La URL que compilas dentro del binario es inmutable de por vida: el cliente la pega a mano y no la vuelve a tocar. Esa restricción decide toda la arquitectura.
Leer →Bajamos el límite de 60 $ a 20 $ esperando menos riesgo. La caída máxima pasó de 224 $ a 2.331 $. Un stop dentro del ruido normal del mercado hace lo contrario de lo que crees.
Leer →La mayoría de robots mezclan la lógica de entrada con la de protección. Cuando la estrategia falla, la protección falla con ella. Así partimos las dos.
Leer →Todos nuestros intentos de cierre fueron rechazados. La lección: si tu protección vive sólo en tu código, no existe cuando más la necesitas.
Leer →Misma configuración, mismos datos, misma ventana. Sólo cambia el modelo de ejecución del simulador. Y el resultado cambia de signo. Un backtest así no puede sostener ninguna decisión.
Leer →El bot de referencia que estudiamos cerraba casi el 99 % de sus ciclos en verde. También cargaba 64.077 $ de pérdida flotante. Un porcentaje de acierto alto no es una ventaja: es un mando que puedes girar.
Leer →Un freno de volatilidad, un cierre por inversión y un conmutador de régimen. Las tres sonaban bien. Las tres salieron peor que no tenerlas. Esto es lo que pasa cuando mides una a una en vez de acumular.
Leer →El flujo real de cómo integrar Claude en el ciclo de desarrollo diario: planificación, generación por bloques, review del diff, tests con semántica real y documentación. Sin hype — lo que funciona.
Leer →Java 21 trajo virtual threads estables y Spring Boot 3.2 los activa con una línea. Qué cambia realmente en tu API, qué no cambia, y el problema del pinning que nadie te cuenta.
Leer →No todos los proyectos necesitan microservicios desde el día uno. El monolito modular resuelve los problemas reales del monolito tradicional sin la complejidad operacional de los microservicios — y te deja la puerta abierta para migrar después.
Leer →Las decisiones de arquitectura de las primeras semanas determinan cuánto duele el proyecto en el mes 6. Cómo organizar módulos por dominio, separar capas y mantener boundaries limpios en NestJS.
Leer →El código generado por IA puede verse perfecto y aun así romper producción. Este checklist cubre los 6 puntos que hay que verificar antes de aprobar cualquier PR generado por un LLM.
Leer →La IA puede refactorizar código con precisión, pero también puede romper producción silenciosamente. Estos son los tipos de cambio donde confiar y donde verificar con cuidado.
Leer →El código generado por IA suele compilar y fallar el code review. La diferencia no está en el modelo, sino en cómo le contamos qué queremos. Cinco prácticas concretas que mueven la aguja.
Leer →Tuurt construye software a medida, integra IA donde agrega valor verificable, y desarrolla videojuegos 2D y mobile. Esto es lo que vas a encontrar en este blog y cómo trabajamos.
Leer →