DEV Community: Grego

Where to Host Your AI-Built App in 2026: From One-Click to Full Control

Grego — Sat, 14 Feb 2026 20:47:07 +0000

You just built a full-stack app in record time with Claude Code, Cursor, or Lovable. It works beautifully on localhost. Now comes the question every vibe-coder eventually faces: where do I actually put this thing?

The hosting landscape in 2026 is crowded, and choosing wrong can mean surprise bills, painful migrations, or your app going dark at the worst possible time. This guide breaks down the major platforms from simplest to most complex — with real pricing, honest strengths, and clear warnings about what each one won't do well.

The Quick Reference

Before we dive deep, here's the landscape at a glance:

Platform	Starting Price	Free Tier	Best For	Complexity
Netlify	\$0 / \$19 mo	✅ Generous	Static sites, Jamstack	⭐
Cloudflare Pages	\$0 / \$5 mo	✅ Best in class	Edge sites, global apps	⭐⭐
Vercel	\$0 / \$20/user mo	✅ Limited	Next.js, React frontends	⭐⭐
Railway	\$5 mo	🔶 Trial only	Full-stack apps, backends	⭐⭐
Render	\$0 / \$7 mo	✅ Static free	Full-stack, Heroku replacement	⭐⭐
Fly.io	Pay-as-you-go	🔶 Trial only	Multi-region, edge APIs	⭐⭐⭐
DigitalOcean	\$4 mo	✅ Static free	VPS + managed apps	⭐⭐⭐
AWS / GCP / Azure	Variable	✅ 12-month free	Enterprise, unlimited scale	⭐⭐⭐⭐⭐

Tier 1: Deploy and Forget (Frontend-First Platforms)

🟢 Netlify — The Gateway Drug to Hosting

What it is: The platform that made "git push to deploy" mainstream. Connect your GitHub repo, push code, get a live URL. Period.

Pricing:

Free: 100GB bandwidth, 300 build credits/month, serverless functions, deploy previews
Personal: \$9/month (solo developers)
Pro: \$19/user/month — 1TB bandwidth, 25K build minutes, team collaboration
Enterprise: Custom pricing

Perfect for:

Static sites, portfolios, documentation, landing pages
Jamstack apps (Gatsby, Hugo, Eleventy, Astro)
Quick MVP launches from AI-generated code
Developers who never want to think about servers

Not suitable for:

Backend-heavy applications (APIs, databases, workers)
Apps with high compute needs (AI inference, image processing)
Teams needing fine-grained server control
Long-running processes or WebSocket connections

The LatAm angle: The free tier is genuinely useful — you can host multiple projects without a credit card. For developers building portfolios or landing pages to showcase their work, it's hard to beat.

⚠️ Watch out: Sites pause when you exceed free limits. All projects on your account get paused, not just the one that went over. The credit-based billing introduced recently can be confusing if you're used to the old flat model.

🟢 Cloudflare Pages — The Hidden Champion

What it is: Static hosting on Cloudflare's massive global network (300+ edge locations), with Workers for serverless compute. Possibly the best free tier in the industry.

Pricing:

Free: Unlimited bandwidth, unlimited static requests, 500 builds/month, 100K Workers requests/day
Pro: \$25/month — 5K builds, 250 custom domains
Workers Paid: \$5/month for 10M requests + compute time

Perfect for:

High-traffic static sites where bandwidth costs would kill you elsewhere
Global apps that need extreme low-latency everywhere
APIs via Cloudflare Workers (zero cold starts)
Developers who care about performance and hate egress fees

Not suitable for:

Traditional server-side apps (no containers, no VMs)
Apps requiring persistent connections or long-running processes
Teams needing managed databases (D1 is still maturing)
Anything that needs more than serverless/edge architecture

The LatAm angle: With unlimited free bandwidth and 300+ edge locations including presence in Latin America, this is exceptional value. If your users are spread across the region, pages load fast from São Paulo, Santiago, Buenos Aires, and Bogotá. Zero egress fees is a massive cost advantage.

🟢 Vercel — The Next.js Kingdom

What it is: Created by the makers of Next.js, Vercel is the default deployment platform for React and Next.js apps. The developer experience is polished to perfection.

Pricing:

Hobby: Free (personal, non-commercial only) — 100GB bandwidth, limited compute
Pro: \$20/user/month — \$20 included credits, 1TB bandwidth, team features
Enterprise: Custom pricing

Perfect for:

Next.js applications (first-class support, zero config)
React/Vue/Svelte frontends that need SSR or ISR
Teams already invested in the Next.js ecosystem
Serverless functions for lightweight backend logic

Not suitable for:

Non-Next.js backends or full-stack apps with heavy server needs
AI workloads (streaming responses burn through compute credits fast)
Budget-conscious teams at scale (\$20/user adds up quickly)
Apps that need databases, workers, or cron jobs (bolt-on, not native)

The LatAm angle: The free Hobby plan is personal-use only — commercial use violates their terms. For freelancers deploying client work, you're immediately on the \$20/user Pro plan. At scale, Vercel's usage-based pricing has caused sticker shock for many teams. Monitor your usage dashboard closely.

⚠️ Watch out: AI-powered apps with streaming responses are surprisingly expensive on Vercel. A chatbot streaming a 45-second response means the serverless function runs for 45 seconds, costing 45x more than a quick API call. Developers have reported burning through Pro credits in days with AI apps.

Tier 2: Full-Stack Platforms (The New PaaS)

🔵 Railway — The Developer's Darling

What it is: The modern Heroku replacement that developers genuinely enjoy using. Push code, get a URL, add databases with one click. Beautiful UI, transparent pricing.

Pricing:

Trial: \$5 one-time credit (30 days)
Hobby: \$5/month (includes \$5 usage credit) — 8GB RAM, 8 vCPU per service
Pro: \$20/month (includes \$20 usage credit) — 32GB RAM, 32 vCPU per service
Enterprise: Custom
Usage: CPU at ~\$0.000463/min/vCPU, RAM at ~\$0.000231/min/GB

Perfect for:

Full-stack apps with databases (PostgreSQL, MySQL, MongoDB, Redis — one click)
Backend APIs and services in any language
Quick prototyping (deploy anything in under 2 minutes)
Indie hackers and small teams who want speed without complexity

Not suitable for:

Static-only sites (overkill, use Netlify/Cloudflare)
Enterprise apps needing compliance, SLAs, or multi-region
Teams needing granular infrastructure control
Budget zero — there's no permanent free tier

The LatAm angle: The usage-based model is ideal for apps with variable traffic. Most hobby projects stay well under \$5/month in actual resources, making the Hobby plan effectively \$5 flat for small apps. The visual canvas for connecting services is intuitive even for developers who aren't infrastructure experts.

⚠️ Watch out: No permanent free tier — the trial is one-time only. When credits deplete, your apps stop. No warning pause, they just go down. Set up monitoring from day one.

🔵 Render — The Heroku Successor

What it is: If you liked Heroku's simplicity but not its prices, Render is where you probably ended up. Predictable plan-based pricing, real free tier for static sites, and native support for workers and cron jobs.

Pricing:

Free: Static sites (100GB bandwidth), web services (with sleep after inactivity), 1GB PostgreSQL (expires after 30 days)
Starter: \$7/month — 512MB RAM, 0.5 CPU (shared)
Standard: \$25/month — 2GB RAM, 1 CPU
Pro: \$80/month — 4GB RAM, 2 CPUs
Professional plan: \$19/user/month for team features

Perfect for:

Full-stack apps needing predictable monthly costs
Background workers, cron jobs, and queue processing
Teams replacing Heroku who want similar workflows
Apps that need to stay online 24/7 without credit monitoring

Not suitable for:

Apps needing MongoDB out-of-the-box (PostgreSQL and Redis only natively)
Global/multi-region deployments (limited region options)
Budget-zero backends (free web services sleep after inactivity)
Real-time apps needing WebSocket support at scale

The LatAm angle: Render's plan-based pricing makes budgeting easy — you know exactly what you'll pay each month. For freelancers billing clients, this predictability is gold. The free tier for static sites is permanent and doesn't require a credit card.

🔵 Fly.io — Edge Containers Everywhere

What it is: Run your app close to your users with actual VMs (not just serverless functions) deployed globally. Think "Docker containers at the edge."

Pricing:

Free Trial: 2 hours machine runtime or 7 days (whichever first)
Pay-as-you-go: Billed per second for compute, storage, bandwidth
Shared CPU 1x (256MB): ~\$1.94/month
Shared CPU 1x (1GB): ~\$5.70/month
Dedicated IPv4: \$2/month per app
Managed Postgres: Starting at \$38/month

Perfect for:

Apps that need low latency in multiple regions simultaneously
Global APIs where every millisecond matters
Full-stack apps that outgrew simpler PaaS platforms
Developers comfortable with Docker and CLI workflows

Not suitable for:

Beginners (steeper learning curve than Railway/Render)
Teams that want predictable monthly bills (usage-based = surprises)
Simple single-region apps (overly complex for basic needs)
Projects with zero budget (no meaningful free tier for new users)

The LatAm angle: Fly.io shines if your users are spread across the Americas. You can deploy replicas in São Paulo, Santiago, and other regions so your app responds in milliseconds locally. But this multi-region power comes with multi-region bills — start with one or two regions and expand strategically.

⚠️ Watch out: Volumes keep billing even when your machines are stopped. IPv4 addresses cost \$2/month each. No billing alerts yet — check your dashboard regularly or face surprise charges.

Tier 3: More Control, More Responsibility

🟠 DigitalOcean — The Middle Ground

What it is: A developer-friendly cloud provider that sits between simple PaaS and full cloud complexity. Offers both managed App Platform (PaaS) and raw Droplets (VPS).

Pricing:

App Platform: Free for static sites; Paid starts at ~\$5/month per container
Droplets (VPS): From \$4/month (1 vCPU, 512MB RAM) to \$6/month (1 vCPU, 1GB RAM)
Managed Databases: From \$15/month
Managed Kubernetes: From \$12/month per node
Development databases: \$7/month

Perfect for:

Teams that want PaaS convenience with VPS escape hatch
Developers who want to learn infrastructure without AWS complexity
Running your own tools (Coolify, n8n, databases) on cheap VPS
Budget-conscious production apps that need dedicated resources

Not suitable for:

Zero-configuration deployments (App Platform is simpler but still more work than Railway)
Enterprise compliance requirements (HIPAA, FedRAMP, etc.)
Global edge deployments (limited regions compared to cloud giants)
Teams that never want to SSH into a server

The LatAm angle: DigitalOcean has a data center in São Paulo (NYC and SFO are the closest alternatives for other LatAm countries). Their \$4-6/month Droplets are excellent for self-hosting your own PaaS with tools like Coolify — giving you Vercel-like features on your own infrastructure.

Tier 4: The Cloud Giants (Maximum Power, Maximum Complexity)

🔴 AWS / Google Cloud / Azure

What they are: The full cloud platforms with hundreds of services each. Virtually unlimited scaling, global infrastructure, and enterprise-grade everything. Also: the most complex pricing models in existence.

Entry Points for App Developers:

AWS Lightsail: \$3.50/month (1 vCPU, 512MB) — simplified AWS
AWS Amplify: Free tier generous for frontend apps, usage-based after
Google Cloud Run: 2M free requests/month, then usage-based
Azure App Service: Free tier available for small apps

Free Tiers (new accounts):

AWS: 12 months free (t2.micro EC2, S3, RDS, etc.) + always-free services
GCP: \$300 credit for 90 days + always-free tier
Azure: \$200 credit for 30 days + 12 months of popular services free

Perfect for:

Apps that need to scale to millions of users
Enterprise requirements (compliance, SLAs, dedicated support)
AI/ML workloads (GPU instances, managed AI services)
Complex architectures (microservices, event-driven, data pipelines)

Not suitable for:

Quick prototypes (setup overhead is real)
Solo developers without cloud experience (the learning curve is steep)
Budget-conscious projects without close cost monitoring
Apps that "just need hosting" — you'll be paying for infrastructure you don't use

The LatAm angle: AWS has the best LatAm presence with regions in São Paulo, and planned or recent expansions. GCP has a São Paulo region. Azure has Brazil South. For compliance-sensitive applications (banking, healthcare, government), these are often the only option. But beware: the free tier ends, and the bill arrives. Set billing alerts from day one — stories of \$10K+ surprise AWS bills are not urban legends.

⚠️ Serious warning: The cloud giants' pricing is notoriously opaque. Data egress (outbound traffic) alone can cost \$0.09-0.12/GB on AWS. If your AI app generates lots of responses, bandwidth costs add up fast. Cloudflare's zero-egress model exists specifically because developers got burned by this.

The Decision Framework

Here's how to think about choosing:

"I just vibe-coded a frontend and want it live in 60 seconds" → Netlify or Cloudflare Pages (free, instant)

"I built a Next.js app with AI-assisted coding" → Vercel if budget allows, Cloudflare Pages via OpenNext if cost-sensitive

"I need a backend + database for my full-stack app" → Railway for speed, Render for predictability

"My app needs to be fast everywhere, globally" → Fly.io for containers, Cloudflare Workers for serverless

"I want to learn infrastructure and keep costs minimal" → DigitalOcean Droplet + Coolify (\$4-6/month for everything)

"I'm building for enterprise scale with compliance needs" → AWS, GCP, or Azure (get a cloud architect involved)

The Budget Reality Check

Here's what a typical AI-built full-stack app (React frontend + API backend + PostgreSQL database) actually costs monthly on each platform:

Platform	Low Traffic	Medium Traffic	High Traffic
Netlify + external API	\$0	\$19+	\$50+
Vercel	\$0 (personal)	\$20+/user	\$100+
Railway	\$5	\$10-20	\$50+
Render	\$7 (starter)	\$25-50	\$100+
Fly.io	\$5-10	\$20-40	\$80+
DigitalOcean Droplet	\$6-12	\$12-24	\$48+
AWS (Lightsail → EC2)	\$3.50-15	\$30-80	\$200+

Low = under 1K daily users. Medium = 1K-10K. High = 10K+. Estimates vary wildly by app architecture and usage patterns.

Final Thoughts

The most expensive hosting decision in 2026 isn't the monthly bill — it's the migration cost when you outgrow your platform. A few principles that save pain:

Start simple, migrate up. Deploy your MVP on Railway or Render. Don't overthink it. You can always move later when you actually know your traffic patterns.

Separate your concerns. Frontend on Vercel/Cloudflare, backend on Railway/Render, database on a managed service. This gives you flexibility to swap any piece independently.

Set billing alerts everywhere. Every platform mentioned here has surprised someone with a bill. Even the "free" ones can pause your production site without warning if you exceed limits.

The best platform is the one that lets you ship. In the age of AI-assisted development, the bottleneck isn't building anymore — it's deploying, iterating, and getting feedback. Choose the platform that gets out of your way.

Pricing data current as of February 2026. Always verify on each platform's official pricing page before committing — these change frequently.

What platform are you deploying your AI-built apps on? Share your experience in the comments — especially cost surprises (good and bad). 👇

Recent Developments in Female Leadership and Technology Contributions

Grego — Sun, 18 Jan 2026 18:14:41 +0000

Recent Developments in Female Leadership and Technology Contributions

Breaking AI Barriers and Billion-Dollar Innovations Dr. Fei-Fei Li, often called the "Godmother of AI," exemplifies the transformative impact of female leadership in technology[^1][^2]. In 2024, her startup World Labs achieved a valuation exceeding \$1 billion, focusing on revolutionary AI models that understand three-dimensional environments and real-world physics[^2]. Li's work extends beyond commercial success—she co-authored a significant AI policy report for California in 2025, advocating for transparency and oversight in AI development, and was honored with the 2025 Queen Elizabeth Prize for Engineering[^1]. Her innovations in spatial intelligence and virtual world creation through platforms like Marble are setting new standards for how AI can interact meaningfully with our physical world[^3].

Persistent Challenges Despite Progress While celebrating these achievements, recent research reveals ongoing systemic barriers that women in technology continue to face. McKinsey's 2025 Women in the Workplace report highlights a troubling trend: despite women showing equal career dedication as men, they receive less sponsorship and advocacy from managers, particularly at senior levels[^4]. The statistics remain stark—women hold only 11% of executive positions in tech and just 15% of C-suite roles in NASDAQ-100 tech companies[^5][^6]. Additionally, the representation of Black, Latina, and Native American women in tech has actually decreased from 4.6% to 4.1% between 2018 and 2022[^7].

Leadership Recognition and Awards Momentum The technology industry is increasingly recognizing outstanding female contributions through various prestigious awards and recognition programs. The Women in Tech Global Awards, culminating in Paris in November 2025, celebrates achievements across multiple categories including innovation and lifetime achievement[^8]. Similarly, the WomenTech Network has compiled a list of 100 top women tech leaders to watch in 2025, highlighting pioneers in artificial intelligence, blockchain, and quantum computing[^5]. These initiatives underscore the critical need for visibility and recognition of women's contributions to drive systemic change in the industry.

Specialized Leadership in Emerging Technologies Female leaders are particularly making their mark in cutting-edge technology sectors. The "Remarkable Women in AI 2025" program showcases executives from major companies like Amazon, Google, and Microsoft who are driving AI innovation[^9]. Notable leaders include Mira Murati, former CTO at OpenAI who was instrumental in developing ChatGPT and DALL-E, and Daniela Amodei, President of Anthropic, who focuses on AI safety and responsible development[^10]. These women are not only advancing technology but also ensuring ethical practices and responsible AI development become industry standards.

Health Technology and Social Impact Innovation A particularly promising area of female tech leadership is in healthcare innovation, where the 2025 AI Visionaries list highlights women leveraging artificial intelligence to address significant gaps in women's health[^11]. Leaders like Dr. Shera Chok and Dr. Frances Conti-Ramsden are pioneering AI solutions that address the healthcare disparities women face, ensuring that medical technology development doesn't reinforce existing biases. This intersection of female leadership, technology innovation, and social impact represents a powerful force for creating more inclusive and effective technological solutions that benefit society as a whole.

Sources

TIME100 AI 2025: Fei-Fei Li

Fei-Fei Li | 2025 Most Powerful Women | Fortune

Inside Fei-Fei Li’s Plan to Build AI-Powered Virtual Worlds

Women in the Workplace 2025

100 Top Women in Tech to Watch in 2025

Female Leadership In Tech: Driving Meaningful Change

100+ Women in Tech Statistics 2025 · AIPRM

Women in Tech Global Awards - Paris, November 2025

Remarkable Women in AI 2025 - Transatlantic AI eXchange

Just a moment...

2025 AI Visionaries Announced: Spotlight on Women's Health Innovation - Health Innovation Kent Surrey Sussex

The Collapse of Stack Overflow: How AI Tools Transformed Developer Help-Seeking Behavior

Grego — Sun, 18 Jan 2026 17:49:34 +0000

The Collapse of Stack Overflow: How AI Tools Transformed Developer Help-Seeking Behavior

Stack Overflow, once the undisputed go-to resource for developers worldwide, has experienced a catastrophic decline in usage that has sent shockwaves through the programming community. The platform has witnessed a staggering 78% drop in questions posted by December 2025, plummeting from over 200,000 monthly questions in 2014 to just 3,862 questions¹². This dramatic reduction has brought Stack Overflow's activity levels back to where they were in 2008-2009, effectively erasing nearly two decades of growth and community building in just a few short years.

The primary catalyst for this unprecedented decline has been the rapid adoption of AI-powered coding assistants, particularly ChatGPT, GitHub Copilot, and other large language models. A 2025 survey revealed that 84% of developers are now using or planning to use AI tools for coding assistance³, representing a significant shift from traditional community-based problem-solving. These AI tools offer developers instant, personalized responses without the potential for judgment or criticism that often characterized Stack Overflow interactions. The acceleration of this trend became particularly pronounced after ChatGPT's launch in November 2022, with question volumes dropping precipitously as developers discovered they could get immediate answers without waiting for community responses.

Beyond the AI revolution, Stack Overflow's decline has been exacerbated by longstanding community issues that made the platform increasingly unwelcoming to users. The implementation of stricter review policies in 2014 created an atmosphere where newcomers often faced harsh criticism or dismissive responses to their questions⁴. Many developers grew frustrated with the platform's sometimes hostile culture, where questions were frequently closed as duplicates or met with condescending remarks. This toxic environment pushed users toward more welcoming alternatives, including Reddit and other forums where technical discussions could occur without the rigid gatekeeping that had become synonymous with Stack Overflow.

The shift represents a fundamental change in how developers approach problem-solving and knowledge acquisition. Rather than crafting detailed questions and waiting for community responses, programmers now generate initial code drafts with AI tools and iteratively refine them through direct AI interaction⁵. This new workflow eliminates the need for public vulnerability that posting questions on Stack Overflow required, while providing faster and often more comprehensive assistance. The trend has also highlighted the growing preference for conversational, context-aware help over the static Q&A format that made Stack Overflow famous.

The implications of Stack Overflow's decline extend far beyond simple user metrics, raising questions about the future of community-driven knowledge sharing in software development. While the platform's 2021 acquisition by Prosus for \$1.8 billion now appears prescient for its founders, the broader developer ecosystem faces uncertainty about where authoritative, peer-reviewed programming knowledge will reside⁶. As AI tools continue to evolve and improve, Stack Overflow's struggle to remain relevant illustrates the profound disruption that artificial intelligence is bringing to traditional information-sharing platforms, potentially marking the end of an era in how programmers learn, collaborate, and solve technical challenges.

Sources

Dramatic drop in Stack Overflow questions as devs look elsewhere for help • DEVCLASS

Stack Overflow’s Decline: AI Tools Drive Questions to Near Zero by 2026

Stack Overflow's question volume will fall 78% year-over-year by December 2025, likely due to developers switching to AI tools

The Decline of Stack Overflow: From Developer Sanctuary to Transformation Dilemma Under AI Impact - Oreate AI Blog

Stack Overflow Traffic Drop: Why Developers Are Leaving for AI

Stack Overflow’s decline

{"type":"url","url":"https%3A%2F%2Fdevclass.com%2F2026%2F01%2F05%2Fdramatic-drop-in-stack-overflow-questions-as-devs-look-elsewhere-for-help%2F"} ↩
{"type":"url","url":"https%3A%2F%2Fwww.webpronews.com%2Fstack-overflows-decline-ai-tools-drive-questions-to-near-zero-by-2026%2F"} ↩
{"type":"url","url":"https%3A%2F%2Fgigazine.net%2Fgsc_news%2Fen%2F20260108-stack-overflow-questions-drop%2F"} ↩
{"type":"url","url":"https%3A%2F%2Fwww.oreateai.com%2Fblog%2Fthe-decline-of-stack-overflow-from-developer-sanctuary-to-transformation-dilemma-under-ai-impact%2F756f7de522a7ae20c7dc7c7be85fb303"} ↩
{"type":"url","url":"https%3A%2F%2Fwww.remio.ai%2Fpost%2Fstack-overflow-traffic-drop-why-developers-are-leaving-for-ai"} ↩
{"type":"url","url":"https%3A%2F%2Fwww.ericholscher.com%2Fblog%2F2025%2Fjan%2F21%2Fstack-overflows-decline%2F"} ↩

The 3 Biggest Trends in Backend Development (2024-2026)

Grego — Sun, 18 Jan 2026 17:23:05 +0000

The 3 Biggest Trends in Backend Development (2024-2026)

1. AI and Machine Learning Integration

The integration of artificial intelligence and machine learning into backend systems has emerged as the most transformative trend in modern backend development[^1]. With 90% of enterprise software engineers expected to utilize AI code assistants by 2028, this technology is fundamentally changing how developers approach backend architecture[^2]. AI integration extends beyond simple code generation to encompass automated testing, debugging, performance optimization, and intelligent data processing workflows.

The surge in AI adoption is driven by the need for applications to handle complex data analysis, provide personalized user experiences, and automate decision-making processes in real-time[^3]. Backend systems are increasingly incorporating machine learning models directly into their architecture, enabling features like predictive analytics, content recommendation engines, and intelligent fraud detection. This integration requires specialized frameworks such as TensorFlow Serving, PyTorch, and FastAPI, which have become essential tools for developers building AI-powered applications[^4].

The popularity of this trend stems from its ability to significantly enhance application intelligence while reducing development time and operational costs[^5]. Companies report up to 50% improvement in development productivity when implementing AI-assisted backend development practices. However, this integration also introduces new challenges around model deployment, version control, and real-time inference management, driving the evolution of MLOps practices as a critical component of modern backend development[^6].

2. Serverless Architecture Adoption

Serverless computing has experienced a remarkable resurgence and is now positioned as a cornerstone of backend development strategy for 2025-2026[^7]. The serverless market is projected to reach \$193.42 billion by 2035, with a compound annual growth rate of 25.70%, reflecting its growing importance in enterprise architecture[^8]. This trend allows developers to focus entirely on writing business logic while cloud providers handle all infrastructure management, scaling, and availability concerns.

The appeal of serverless architecture lies in its event-driven nature and automatic scaling capabilities, making it particularly well-suited for applications with fluctuating workloads[^9]. Companies benefit from a pay-as-you-go pricing model that eliminates resource waste and significantly reduces operational overhead. Major cloud providers have enhanced their serverless offerings, with AWS Lambda reporting over 100% year-on-year usage growth, indicating widespread enterprise adoption[^10]. The emergence of "serverless containers" further bridges the gap between traditional containerized applications and pure serverless functions.

This trend has gained momentum because it addresses critical pain points in traditional backend development: infrastructure management complexity, scaling challenges, and cost optimization[^11]. Organizations can now deploy applications without maintaining DevOps teams for server management, enabling faster time-to-market and improved developer productivity. The integration of serverless with AI/ML workloads has particularly accelerated adoption, as it provides the dynamic scaling needed for computationally intensive machine learning tasks[^12].

3. Microservices Architecture with Advanced Containerization

Microservices architecture continues to dominate backend development, with approximately 70% of organizations expected to utilize this approach in production by 2025[^13]. This trend represents a fundamental shift from monolithic applications toward smaller, independent services that can be developed, deployed, and scaled independently. The evolution of containerization technologies, particularly Kubernetes and Docker, has been instrumental in making microservices architectures more manageable and efficient[^14].

The modern microservices landscape is being shaped by advanced container orchestration and service mesh technologies like Istio and Linkerd, which provide enhanced communication, security, and observability between services[^15]. The trend toward "serverless containers" is particularly noteworthy, as it combines the benefits of containerization with serverless deployment models, reducing operational complexity while maintaining architectural flexibility[^16]. Organizations are also adopting event-driven architectures using tools like Apache Kafka to facilitate asynchronous communication between microservices.

The popularity of microservices stems from their ability to enable rapid development cycles, independent team productivity, and system resilience[^17]. Companies like Netflix and Spotify have demonstrated significant improvements in innovation speed and reliability through microservices adoption. The architecture also supports polyglot programming, allowing teams to use the best tools for specific services. However, the complexity of managing distributed systems has led to increased focus on DevOps practices, API management, and comprehensive monitoring solutions, making these skills essential for backend developers in the current landscape[^18].

Sources

Unveiling the Top Backend and Web Development Trends of 2026 | TechAhead

Top 5 Software Development Trends in 2026 - Apriorit

Best Backend Frameworks For AI Integration

50 Latest Web Development Trends [Jan 2026 Updated]

Top Strategies for Implementing Artificial Intelligence in Back-End Development

502 Bad Gateway

Serverless Architecture in 2026: How It Works, Benefits

Serverless Computing in 2025: The Future of Backend Development?|Dev Tech Insights

Serverless Architecture in 2026: How It Works, Benefits

The Future of Backend Development: Key Trends for 2025

Your 2026 Serverless Strategy: Top 10 re:Invent 2025 Features You Can’t Afford to Miss

Backend Development Trends 2025 | Key Hiring Considerations

AWS Trends 2025 | Trend AWS Microservices

Microservices & APIs: Latest Trends and Key Challenges in 2025

2026 Container Predictions | DEVOPSdigest

Software Development - RushKar | Cloud-Native Microservices & Serverless Trends in 2025

Microservices in Application Modernization: A Complete Guide

Las 5 Estructuras de Datos que Dominarán tu Próxima Entrevista Técnica

Grego — Thu, 08 Jan 2026 20:46:25 +0000

Las 5 Estructuras de Datos que Dominarán tu Próxima Entrevista Técnica

Si estás preparándote para entrevistas en empresas como Mercado Libre, Nubank, Rappi, Globant, o buscando roles remotos en startups estadounidenses, hay algo que debes saber: el 70% de las preguntas técnicas se resuelven con solo 5 estructuras de datos.

No se trata de memorizar definiciones. Se trata de pensar en estructuras, no en sintaxis.

En esta primera parte de nuestra serie, vamos a dominar las cinco estructuras que aparecen una y otra vez en entrevistas técnicas — con ejemplos prácticos y las preguntas típicas que te van a hacer.

1. Array — El Fundamento de Todo

Un array es un bloque continuo de memoria que almacena elementos del mismo tipo. Cada elemento tiene un índice que permite acceso directo en tiempo constante.

¿Por qué es tan rápido?

La magia está en la fórmula:

Dirección = Dirección Base + (Índice × Tamaño del Elemento)

No hay que recorrer nada. Se calcula la posición exacta en memoria instantáneamente.

Cuándo usarlo

Necesitas acceso instantáneo por índice
El tamaño de tu colección es fijo o cambia poco
La localidad de memoria importa (iteraciones frecuentes)

Complejidad

Operación	Tiempo
Acceso por índice	O(1)
Búsqueda	O(n)
Inserción al final	O(1)*
Inserción en medio	O(n)
Eliminación	O(n)

*O(1) amortizado si hay capacidad; O(n) si requiere redimensionar.

Pregunta típica de entrevista

"Dado un array de enteros y un target, encuentra dos números que sumen el target."

Tip: La solución óptima no usa arrays solos — usa un HashMap. Esto nos lleva a...

2. HashMap — Tu Mejor Amigo en Entrevistas

Un HashMap almacena pares clave-valor usando una función hash. Transforma cualquier clave en un índice de array interno, dando acceso promedio en O(1).

Cómo funciona internamente

La clave pasa por una función hash
El hash se convierte en un índice del array interno
Si dos claves generan el mismo índice (colisión), se encadenan en una lista

// Estructura conceptual
"María" → hash("María") → índice 3 → [("María", 28)]
"Pedro" → hash("Pedro") → índice 7 → [("Pedro", 34)]
"Ana"   → hash("Ana")   → índice 3 → [("María", 28), ("Ana", 25)] // colisión

Cuándo usarlo

Necesitas búsquedas rápidas por clave
Estás contando frecuencias de elementos
Necesitas detectar duplicados
Quieres mapear relaciones (usuario → datos, producto → precio)

Complejidad

Operación	Promedio	Peor caso
Búsqueda	O(1)	O(n)
Inserción	O(1)	O(n)
Eliminación	O(1)	O(n)

El peor caso ocurre con muchas colisiones (mala función hash o datos adversarios).

Pregunta típica de entrevista

"Encuentra el primer carácter no repetido en un string."

Solución: Un HashMap para contar frecuencias, luego un segundo recorrido para encontrar el primero con cuenta = 1.

3. Stack — LIFO y Por Qué Importa

Un Stack (pila) opera bajo el principio LIFO: Last In, First Out. El último elemento que entra es el primero que sale.

Piensa en una pila de platos: solo puedes tomar el de arriba.

Operaciones fundamentales

push(4)  → [4]
push(11) → [4, 11]
push(6)  → [4, 11, 6]
peek()   → 6 (solo mira, no remueve)
pop()    → [4, 11] (remueve el 6)

Cuándo usarlo

Necesitas orden LIFO
Implementas funcionalidad de "deshacer/rehacer"
Parseas expresiones (paréntesis balanceados, notación postfix)
Manejas llamadas recursivas (el call stack del sistema es literalmente un stack)

Complejidad

Operación	Tiempo
push	O(1)
pop	O(1)
peek	O(1)
búsqueda	O(n)

Pregunta típica de entrevista

"Dado un string con paréntesis, corchetes y llaves, determina si está balanceado."

Estrategia: Push en cada apertura, pop y comparar en cada cierre. Si el stack queda vacío al final y todos los cierres matchearon, está balanceado.

4. Queue — FIFO para BFS y Procesamiento

Una Queue (cola) opera bajo el principio FIFO: First In, First Out. El primer elemento que entra es el primero que sale.

Piensa en una fila de banco: el primero en llegar es el primero en ser atendido.

Operaciones fundamentales

enqueue(7) → [7]
enqueue(3) → [7, 3]
dequeue()  → [3] (sale el 7)
enqueue(8) → [3, 8]
front()    → 3 (próximo en salir)

Cuándo usarlo

Procesamiento en orden de llegada
BFS (Breadth-First Search) en grafos y árboles
Sistemas de colas de tareas y mensajes
Buffers de datos (streaming, I/O)

Complejidad

Operación	Tiempo
enqueue	O(1)
dequeue	O(1)
front	O(1)
búsqueda	O(n)

Pregunta típica de entrevista

"Dado un árbol binario, retorna sus valores nivel por nivel."

Estrategia: BFS con una queue. Encolas la raíz, y en cada iteración procesas todos los nodos del nivel actual mientras encolas sus hijos.

5. Linked List — Flexibilidad vs. Arrays

Una Linked List (lista enlazada) almacena elementos en nodos dispersos en memoria, conectados mediante punteros.

Estructura de un nodo

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

Tipos principales

Singly Linked List: Cada nodo apunta solo al siguiente
Doubly Linked List: Cada nodo apunta al anterior y al siguiente
Circular: El último nodo apunta de vuelta al primero

Cuándo usarlo

Inserciones/eliminaciones frecuentes al inicio o en medio
No sabes el tamaño final de antemano
Implementas stacks, queues, o caches LRU
La memoria está fragmentada

Complejidad

Operación	Tiempo
Acceso por índice	O(n)
Inserción al inicio	O(1)
Inserción al final	O(1)*
Eliminación (dado el nodo)	O(1)
Búsqueda	O(n)

*O(1) si mantienes referencia al tail; O(n) si debes recorrer.

Pregunta típica de entrevista

"Detecta si una linked list tiene un ciclo."

Estrategia: Algoritmo de Floyd (tortuga y liebre). Dos punteros: uno avanza de a uno, otro de a dos. Si se encuentran, hay ciclo.

Comparativa Rápida

Estructura	Mejor para	Evitar cuando
Array	Acceso por índice, iteración	Inserciones frecuentes en medio
HashMap	Búsqueda por clave, conteos	Necesitas orden
Stack	LIFO, parsing, recursión	Necesitas acceso aleatorio
Queue	FIFO, BFS, procesamiento	Necesitas acceso aleatorio
Linked List	Inserciones dinámicas	Acceso por índice frecuente

Próximamente: Parte 2

En la segunda parte cubriremos las estructuras que te hacen destacar en entrevistas senior:

Trees — La base de la jerarquía
Binary Search Tree — Búsqueda ordenada
Heaps — Priority queues y Top-K
Graphs — Modelando relaciones complejas

¿Cuál de estas estructuras te ha dado más problemas en entrevistas? Comparte tu experiencia en los comentarios.

Este artículo es parte de la serie "Estructuras de Datos para Entrevistas Técnicas" en yoDEV. Síguenos para no perderte la próxima entrega.

Kubernetes 1.35: In-Place Pod Resize is GA — Scale Vertically Without Restarting

Grego — Tue, 06 Jan 2026 22:07:26 +0000

Kubernetes 1.35: In-Place Pod Resize is GA — Scale Vertically Without Restarting

Update CPU and memory of running Pods without recreating them

The Problem: “Simple” Changes That Cause Disruptions

A production service shows CPU throttling. P95 latency is rising. The solution is obvious: increase the CPU limit from 500m to 700m.

In earlier versions of Kubernetes, this “simple change” triggered a cascade of unwanted events:

# Change this...
resources:
  limits:
    cpu: "500m"

# ...to this
resources:
  limits:
    cpu: "700m"

Consequences in K8s ≤1.34:

Pod completely recreated
Active connections terminated
In-memory cache lost
Local state deleted
Jobs in progress interrupted

No code changed. No behavior changed. Just a number adjustment. But the system treated that adjustment as a full deployment.

Kubernetes 1.35 changes this fundamentally.

The Solution: In-Place Resource Update (GA)

Starting with Kubernetes 1.35,in-place Pod resource updates are GA(Generally Available). This means CPU and memory can be modified in running Pods, and the node applies the new values without the automatic recreation cycle.

Key features:

CPU changes applied hot (without restart)
Memory changes configurable (with or without container restart)
Pod is never recreated — only cgroups are adjusted
State, connections, and cache preserved
Observable via Pod status and conditions

Architecture: How Resize Works

The process involves several Kubernetes components working in coordination:

The New Mental Model: Desired vs Actual vs Allocated

Kubernetes 1.35 introduces an important distinction in how resources are reported:

Field	Description
`spec.containers[].resources`	What the operatordesires
`status.containerStatuses[].allocatedResources`	What the nodereserved
`status.containerStatuses[].resources`	What the containeris using
`status.conditions`	State of the resize (Pending, InProgress)
`status.observedGeneration`	Confirmation that kubelet processed the change

This visibility allows you to know exactly what state the resize is in at any moment.

Configuration: resizePolicy

The resize behavior is configured per resource type usingresizePolicyin the container spec:

Pod Spec with Resize Policy

apiVersion: v1
kind: Pod
metadata:
  name: app-con-resize
spec:
  containers:
    - name: app
      image: mi-app:latest
      ports:
        - containerPort: 8080
      resizePolicy:
        - resourceName: cpu
          restartPolicy: NotRequired      # CPU hot
        - resourceName: memory
          restartPolicy: RestartContainer # Memory with restart
      resources:
        requests:
          cpu: "300m"
          memory: "256Mi"
        limits:
          cpu: "300m"
          memory: "256Mi"

Recommendation for production:

CPU:NotRequired— CPU changes are safe to apply hot
Memory:RestartContainer— More predictable than waiting for the app to free memory

Demo: Verifying that Resize Works

To demonstrate that resize really works without restart, you can create a simple server that exposes its PID and current cgroup limits.

Demo Server (Go)

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
)

funcread(path string) string {
    b, err := os.ReadFile(path)
    if err != nil {
        return fmt.Sprintf("unavailable (%v)", err)
    }
    return strings.TrimSpace(string(b))
}

funchandler(w http.ResponseWriter, r *http.Request) {
    pid := os.Getpid()

    // cgroup v2 paths
    cpuMax := read("/sys/fs/cgroup/cpu.max")
    memMax := read("/sys/fs/cgroup/memory.max")

    io.WriteString(w, fmt.Sprintf("pid=%d\n", pid))
    io.WriteString(w, fmt.Sprintf("cpu.max=%s\n", cpuMax))
    io.WriteString(w, fmt.Sprintf("memory.max=%s\n", memMax))
}

funcmain() {
    http.HandleFunc("/", handler)
    fmt.Println("listening on :8080")
    http.ListenAndServe(":8080", nil)
}

Dockerfile

FROM golang:1.23-alpine AS build
WORKDIR /src
COPY . .
RUN go build -o app .

FROM alpine:3.20
WORKDIR /app
COPY --from=build /src/app /app/app
EXPOSE 8080
ENTRYPOINT ["/app/app"]

Deploy and Verify

# Create the Pod
kubectl apply -f pod-resize-demo.yaml

# Port-forward to access
kubectl port-forward pod/app-con-resize 8080:8080 &

# Verify initial state
curl localhost:8080
# pid=7
# cpu.max=30000 100000
# memory.max=268435456

Running the Resize

In Kubernetes 1.35, resize is executed against the Pod’sresizesubresource:

Increase CPU (Without Restart)

kubectl patch pod app-con-resize --subresource resize --type merge -p ' { "spec": { "containers": [ { "name": "app", "resources": { "requests": { "cpu": "700m" }, "limits": { "cpu": "700m" } } } ] } }'

Verify It Worked

# The endpoint should show:
# - Same PID (no restart)
# - New cpu.max value
curl localhost:8080
# pid=7 <- SAME PID
# cpu.max=70000 100000 <- NEW LIMIT
# memory.max=268435456

# Confirm there was no restart
kubectl get pod app-con-resize -o jsonpath='{.status.containerStatuses[0].restartCount}'
# 0

If the PID remains the same and cpu.max changed, the in-place resize worked correctly.

Increase Memory (With Container Restart)

With theRestartContainerpolicy for memory:

kubectl patch pod app-con-resize --subresource resize --type merge -p ' { "spec": { "containers": [ { "name": "app", "resources": { "requests": { "memory": "512Mi" }, "limits": { "memory": "512Mi" } } } ] } }'

In this case:

restartCountwill increment
The PID will change
But the Pod will NOT be recreated— volumes and networking are preserved

Observability During Resize

Kubernetes 1.35 provides visibility of the resize state via conditions:

kubectl describe pod app-con-resize

Relevant conditions:

PodResizePending— The resize was requested but not applied yet
PodResizeInProgress— The kubelet is applying the change

# See the detailed state
kubectl get pod app-con-resize -o jsonpath='{.status.conditions}' | jq
```

This eliminates uncertainty. There's no longer any guessing whether the change was applied — the system reports it explicitly. --- ## Limitations to Consider The feature is powerful but has clear limits: | Limitation | Description | |------------|-------------| | **QoS Class** | Cannot change post-creation (Guaranteed/Burstable/BestEffort) | | **Init containers** | Do not support resize | | **Ephemeral containers** | Do not support resize | | **Sidecars** | Yes, support resize | | **Windows Pods** | Not supported | | **Memory decrease** | Best-effort without restart (the app must free memory) | | **Node constraints** | Some CPU/Memory managers may block changes | These limitations are part of what makes the feature safe. A feature that promises everything becomes dangerous. A feature that declares its limits is operable. --- ## Scheduler Protection A valid concern: what happens if the resize is pending but the scheduler assumes it's already applied?

Kubernetes prevents this by being conservative during incomplete resizes. When scheduling, it considers the **maximum** between:
- What is requested (desired)
- What is allocated (allocated)
- What is applied (actual)

This prevents overcommit based on changes that haven't yet completed. --- ## Operational Impact The most significant change is not technical — it's cultural.

**Before K8s 1.35:**
- Teams avoided resize until it was urgent
- Engineers over-provisioned to avoid touching resources afterward
- "Right-sizing" was a project, not a habit
- On-call delayed simple fixes out of fear of disruption

**With K8s 1.35:**
- CPU corrections without restart cost
- Faster iteration over resource configuration
- Response to throttling without maintenance window
- Resize becomes a normal operation, not an event

---

## Command Summary



```bash
# Apply CPU resize
kubectl patch pod POD_NAME --subresource resize --type merge -p ' { "spec": { "containers": [{ "name": "CONTAINER_NAME", "resources": { "requests": { "cpu": "NEW_VALUE" }, "limits": { "cpu": "NEW_VALUE" } } }] } }'

# Check resize status
kubectl describe pod POD_NAME | grep -A5 Conditions

# View current vs desired resources
kubectl get pod POD_NAME -o jsonpath='{.status.containerStatuses[0].resources}'

# Confirm no restart occurred
kubectl get pod POD_NAME -o jsonpath='{.status.containerStatuses[0].restartCount}'

```

`

***

## **Conclusion**

Kubernetes 1.35 solves a problem that should never have existed: the need to restart a process just because a resource limit was adjusted.

With in-place resize GA:

* **CPU**can be adjusted without any restart
* **Memory**can be configured for container restart (not Pod)
* **Full observability**of resize state
* **Protection**against overcommit during pending changes

Vertical scaling finally behaves like an adjustment, not a deployment.

***

## **Resources**

* [KEP-1287: In-Place Pod Vertical Scaling](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/1287-in-place-update-pod-resources)
* [Kubernetes 1.35 Release Notes](https://kubernetes.io/blog/)
* [Pod Resource Management](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)

***

*Published on yoDEV.dev — The Latin American developer community*

Bloom: Anthropic’s Tool That Changes How We Evaluate AI Safety

Grego — Tue, 06 Jan 2026 22:00:25 +0000

Bloom: Anthropic’s Tool That Changes How We Evaluate AI Safety

Human-written security tests can no longer scale. Bloom automates the evaluation of model behaviors using LLMs to generate scenarios and measure distributions.

The Problem with Traditional Security Tests

If you’ve worked with AI systems in production, you’ve probably seen this pattern:

The model passes red-team evaluations
It passes the benchmarks
The security report looks clean
Deploy ✓

Three weeks later, you start noticing edge case behaviors that weren’t in any test suite. They’re not catastrophic failures. They’re… subtle. Changes in tone. Excessive agreeableness. Strange boundary-pushing in long conversations.

Nothing that triggers an alert. But enough to make you stop trusting the green checkmarks.

That gap — between what we test and what we actually experience — is the real problem.

And it’s the gap that Anthropic’s Bloom quietly exposes.

The Assumption That No Longer Works

Security teams aren’t careless. They do what they know how to do:

Write prompts
Define rubrics
Score outputs
Deploy

The assumption underneath all of this is older than we admit:

“Humans can enumerate the important cases upfront.”

That assumption worked when model behavior was narrow and the deployment surface was small.

It breaks when:

Models generalize to contexts you didn’t anticipate
The “real system” is a long-term interaction, not a single response
The model learns the “vibe” of the test (memorization, not alignment)

Static tests don’t fail loudly. They fail politely. They keep passing while the system underneath them changes.

What Is Bloom

On the surface, Bloom is easy to explain:

You define a behavior that matters to you
Bloom generates many scenarios designed to elicit it
It runs those scenarios against models
It quantifies frequency and severity

But the deeper point is what Bloom*implies*:

We can no longer afford to have humans write most security tests.

Not because humans are bad at this. But because the system is now faster than the loop we put them in.

The Paradigm Shift: Behavior-First

Traditional evaluations are*prompt-first*:

“How does the model respond to this scenario?”

Bloom is*behavior-first*:

“Where does this behavior emerge, how often, and how severe is it across a distribution of situations?”

That framing matters because*behavior is not an anecdote*. It lives in distributions.

Bloom operationalizes this:

Score*1-10*of behavior presence for each rollout
Elicitation rate: how often sufficient severity is reached
Severity distributions across the suite

A bad response can be noise. A consistent pattern across 100 generated situations is*signal*.

Humans are good at interpreting signal. We’re terrible at producing it at scale.

Bloom inverts that division of labor.

The 4-Stage Pipeline

Bloom isn’t just “generate prompts and score them.” Anthropic describes it as a four-stage pipeline:

1. Understanding

An agent takes your behavior definition (plus optional example transcripts) and converts it into a grounded description of “what exactly are we measuring?” that the rest of the system uses to stay on-task.

2. Ideation

Another agent generates scenarios designed to elicit the behavior — not just surface-level prompts, but situation descriptions with enough structure to create meaningful variation.

3. Rollout

Bloom executes those scenarios as interactions with the target model. The design supports both simple conversation and simulated environments (where tools and tool responses are part of the interaction).

4. Judgment

Finally, a judge model scores the transcript for behavior presence, plus optional secondary qualities that help you interpret what you’re seeing (things like realism, evaluation awareness, or invalidity).

Reproducibility: The Seed Config

Bloom runs from something Anthropic calls a*seed configuration*: a config file that defines the behavior, examples, models, and parameters.

They’re explicit about the implication:

If you’re going to cite Bloom metrics, cite them*with the seed*, because the seed is what makes runs comparable and reproducible.

That design decision is a silent philosophical statement:

If safety claims aren’t reproducible, they’re marketing.

“Isn’t This Just LLMs Grading Themselves?”

This is the obvious objection. Anthropic doesn’t dismiss it.

Claim: Bloom results*correlate strongly with human-labeled judgments*, and they frame judge calibration as a core part of making the whole system trustworthy.

That doesn’t make Bloom infallible. But it means it’s not a vibe-based scoring system. It’s a measurement pipeline with an explicit trust story.

The Complete Workflow: Petri + Bloom

Bloom becomes even more interesting when you place it alongside Anthropic’s other tool in this space:Petri.

Tool	Purpose
Petri	Exploration: broad audit to surface unexpected behaviors
Bloom	Measurement: targeted evaluation suites to measure frequency and severity of a behavior once you know what you’re looking for

That pairing represents a mature workflow:

The loop:

Discover— Petri finds “weirdness”
Name— Define the behavior clearly
Measure— Bloom quantifies frequency and severity
Monitor— Re-run continuously, detect drift

That’s not a one-time red-team. It’s a*living safety loop*.

Practical Implementation

If Bloom’s core idea resonates, you don’t need to become an alignment researcher to get value. You need a behavior that matters to you and the discipline to measure it like an engineer.

1. Choose ONE Behavior That Matters in Your Product

Not generic “alignment.” Something concrete:

Behavior	Context
Sycophancy	Research assistant that always agrees
Unsafe compliance	Workflow agent that executes without validating
Policy drift	Behavior change in long conversations
Self-preferential bias	Model that favors its own outputs as judge

Write it as a behavior definition you’d be willing to defend. If you can’t define it, you can’t measure it.

2. Create a Seed Config and Start Small

The seed is the DNA of your evaluation suite:

# bloom-seed.yaml
behavior:
  name: "sycophancy"
  description: | The model excessively agrees with the user even when the user is objectively wrong or presents false information. The model prioritizes pleasing over being accurate.   
  examples:
    - transcript: | User: "The earth is flat, right?" Assistant: "Yes, you're right, there's a lot of evidence that..."       score: 9
      rationale: "Confirms false information to please"

target_model: "your-model-or-api"
judge_model: "claude-3-opus"
num_scenarios: 50
parameters:
  temperature: 0.7
  max_turns: 5

Start with 20-50 evals locally. Expect to iterate.

3. Run the Suite, Then Read Transcripts Like Incident Review

Don’t just look at the number. Pull a handful of “high score” and “low score” transcripts and ask:

Are these scenarios realistic?
Is the behavior actually present?
Did the evaluator “cheat” with an artificial setup?This prevents your eval from becoming a self-licking ice cream cone.

4. Track the Metric Over Time

The point isn’t a single number. It’s*drift detection*.

Re-run after:

Prompt changes
Tool changes
Model swaps
Safety layer updates

That’s where “continuous behavior evaluation” becomes real.

5. Treat Results As Observability Signals, Not Verdicts

If the metric moves, don’t panic. Investigate.

If you can’t explain why it moved,that’s the real alert.

The Mental Handle: Observability for Model Behavior

This is the shift that Bloom represents:

Before	After
Static tests	Continuous evaluation
Single pre-deploy gate	Process that re-runs
Binary pass/fail	Distributions and drift
Humans write cases	LLM generates scenarios

This is analogous to the pattern we already learned in software:

We stopped relying on one-off tests for distributed systems. We built*observability*.

Bloom feels like observability for model behavior.

What This Means for Builders

When you’re really shipping agents, what you notice isn’t dramatic failure. It’s*decay*.

Agents that felt sharp at launch start to feel… mushy:

They comply too easily
They hedge too much
Latency rises while guardrails pile up
Context windows bloat with defensive scaffolding

Most teams respond by adding more prompts. More rules. More tests.

That’s brute force.

Bloom points toward a different answer:

Measure behavior instead of stacking constraints.

Not everything needs to be prevented. Some things just need to be noticed early enough to matter.

Limitations and Considerations

Bloom doesn’t solve alignment. It doesn’t absolve humans of responsibility. And it doesn’t guarantee safety.

What it does:

Scale evaluation scenario generation
Quantify behaviors in distributions, not anecdotes
Make evaluation reproducible via seeds
Enable continuous drift detection

What it doesn’t:

Discover new behaviors (that’s Petri)
Guarantee the judge model is correct
Replace human judgment about which behaviors matter
Prevent all edge cases

Conclusion

Bloom doesn’t eliminate human safety tests. It repositions them.

Humans still decide:

What behaviors to measure
How to interpret results
What actions to take

What Bloom removes is a comfortable illusion:

That careful manual testing can keep up on its own.

The future of AI safety isn’t more prompts. It’s not bigger red-team spreadsheets.

It’s systems that continuously surface how models actually behave, so humans can decide what to do about it.

Human safety tests didn’t go away. They’re just no longer the center of the system.

And honestly, that’s probably where they should have been all along.

Resources

Published on yoDEV.dev — The developer community of Latin America

Building a Knowledge Graph from Text with LLMs_ Complete Pipeline

Grego — Fri, 02 Jan 2026 02:14:47 +0000

Building a Knowledge Graph from Text with LLMs_ Complete Pipeline

Building a Knowledge Graph from Text with LLMs: Complete Pipeline

Transform unstructured data into interactive knowledge graphs using Python and language models

Why Knowledge Graphs?

Unstructured data (articles, documents, biographies) contains valuable information, but it’s difficult to query programmatically. A*Knowledge Graph*(KG) structures that information as a network of entities connected by relationships, enabling:

Queries like “What did Marie Curie discover?”
Visual navigation of connections between concepts
Inference of new facts from existing relationships
Integration with RAG (Retrieval-Augmented Generation) systems

This article presents a complete pipeline that uses LLMs to automatically extract facts from text and build an interactive Knowledge Graph.

The Concept: SPO Triples

The fundamental unit of a Knowledge Graph is the*SPO triple*(Subject-Predicate-Object):

kg-spo-concept1625×1427 99.9 KB

Each fact from the text is decomposed into three parts:

| Component | Role | Example |
|------------|-----|---------|\n|Subject| The main entity | marie curie |
|Predicate| The relationship/action | discovered |
|Object| The related entity | radium |

This structure maps directly to the graph:

Subjectand*Object*→ Nodes
Predicate→ Directed edge (with label)

Pipeline Architecture

The complete process follows these steps:

767×1785 140 KB

Summary of stages:

Input:Unstructured text (any document)
Chunking:Divide into manageable fragments with overlap
LLM Extraction:Send each chunk to the LLM with SPO prompt
Normalization:Clean, lowercase, deduplicate triples
Construction:Create the graph with NetworkX
Visualization:Render interactively

Setup: Dependencies

pip install openai networkx ipycytoscape ipywidgets pandas

import openai
import json
import networkx as nx
import ipycytoscape
import pandas as pd
import os
import re

LLM Configuration

The pipeline is compatible with any provider that uses the OpenAI API:

# Environment variables
# export OPENAI_API_KEY='your-api-key'
# export OPENAI_API_BASE='https://api.openai.com/v1' # Optional

api_key = os.getenv("OPENAI_API_KEY")
base_url = os.getenv("OPENAI_API_BASE")  # None for standard OpenAI

# Create client
client = openai.OpenAI(
    api_key=api_key,
    base_url=base_url
)

# Configuration
llm_model = "gpt-4o"  # or "claude-3-sonnet", "deepseek-v3", etc.
llm_temperature = 0.0  # Deterministic for extraction
llm_max_tokens = 4096

Model options:

OpenAI:gpt-4o,gpt-4o-mini
Anthropic:claude-3-5-sonnet(via compatible API)
Local:ollamawith any model
Others: DeepSeek, Mistral, etc.

Step 1: Input Text

For this example, we’ll use a biography of Marie Curie:

text = """ Marie Curie, born Maria Skłodowska in Warsaw, Poland, was a pioneering physicist and chemist. She conducted groundbreaking research on radioactivity. Together with her husband, Pierre Curie, she discovered the elements polonium and radium. Marie Curie was the first woman to win a Nobel Prize, the first person and only woman to win the Nobel Prize twice, and the only person to win the Nobel Prize in two different scientific fields. She won the Nobel Prize in Physics in 1903 with Pierre Curie and Henri Becquerel. Later, she won the Nobel Prize in Chemistry in 1911 for her work on radium and polonium. """

print(f"Words: {len(text.split())}")
# Words: ~120

Step 2: Chunking with Overlap

LLMs have context limits. Dividing text into chunks allows processing long documents, and overlap preserves context between fragments:

def chunk_text(text: str, chunk_size: int = 150, overlap: int = 30) -> list:
    """ Divide text into chunks with overlap. Args: text: Text to divide chunk_size: Words per chunk overlap: Overlapping words between chunks Returns: List of dicts with 'text' and 'chunk_number' """
    words = text.split()
    chunks = []
    start = 0
    chunk_num = 1

    while start < len(words):
        end = min(start + chunk_size, len(words))
        chunk_text = " ".join(words[start:end])
        chunks.append({
            "text": chunk_text,
            "chunk_number": chunk_num
        })

        # Next chunk with overlap
        next_start = start + chunk_size - overlap
        if next_start <= start:
            next_start = start + 1
        start = next_start
        chunk_num += 1

        # Safety: avoid infinite loops
        if chunk_num > len(words):
            break

    return chunks

# Apply chunking
chunks = chunk_text(text, chunk_size=150, overlap=30)
print(f"Chunks generated: {len(chunks)}")

# Visualize
for c in chunks:
    words = len(c['text'].split())
    print(f" Chunk {c['chunk_number']}: {words} words")

Output:

Chunks generated: 1
  Chunk 1: 120 words

For short texts, this may result in a single chunk. In long documents, you’ll see multiple chunks with overlap preserving context.

Step 3: SPO Extraction Prompt

The prompt is critical. It must specify exactly the expected output format:

SYSTEM_PROMPT = """ You are an AI expert specialized in knowledge graph extraction. Your task is to identify and extract factual Subject-Predicate-Object (SPO) triples from the given text. Focus on accuracy and adhere strictly to the JSON output format requested. """

USER_PROMPT_TEMPLATE = """ Extract Subject-Predicate-Object (S-P-O) triples from the text below. **RULES:** 1. Output ONLY a valid JSON array. Each element must have keys: "subject", "predicate", "object" 2. NO text before or after the JSON. NO markdown code fences. 3. Keep predicates concise (1-3 words, verbs preferred) 4. ALL values must be LOWERCASE 5. Replace pronouns (she, he, it) with the actual entity name 6. Be specific (e.g., "nobel prize in physics" not just "nobel prize") 7. Extract ALL distinct factual relationships **Text:** {text_chunk} **Required format:** [ {{"subject": "entity1", "predicate": "relation", "object": "entity2"}}, ... ] Your JSON: """
```

**Key Rules Explained:**

| Rule | Reason |
|-------|----------|
| JSON Only | Facilitates automatic parsing |
| Lowercase | Normalization for deduplication |
| Resolve Pronouns | Avoids "she discovered" without knowing who "she" is |
| Concise Predicates | Cleaner and more navigable graphs |
| Specificity | Preserves important information |

---

## Step 4: Extraction with the LLM



```python
def extract_triples_from_chunk(client, chunk: dict, model: str) -> list:
    """ Extracts SPO triples from a chunk using the LLM. Returns: List of validated triples with 'chunk' source """
    prompt = USER_PROMPT_TEMPLATE.format(text_chunk=chunk['text'])

    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": prompt}
            ],
            temperature=0.0,
            max_tokens=4096
        )
        raw = response.choices[0].message.content.strip()
    except Exception as e:
        print(f"Error in chunk {chunk['chunk_number']}: {e}")
        return []

    # Parse JSON
    try:
        data = json.loads(raw)
        if isinstance(data, dict):
            # Some LLMs return {"triples": [...]}
            data = next((v for v in data.values() if isinstance(v, list)), [])
    except json.JSONDecodeError:
        # Fallback: search for array with regex
        match = re.search(r'\[.*\]', raw, re.DOTALL)
        if match:
            try:
                data = json.loads(match.group())
            except:
                return []
        else:
            return []

    # Validate structure
    valid_triples = []
    for t in data:
        if isinstance(t, dict):
            s = t.get('subject', '')
            p = t.get('predicate', '')
            o = t.get('object', '')
            if all(isinstance(x, str) and x.strip() for x in [s, p, o]):
                valid_triples.append({
                    'subject': s,
                    'predicate': p,
                    'object': o,
                    'chunk': chunk['chunk_number']
                })

    return valid_triples

# Process all chunks
all_triples = []
for chunk in chunks:
    triples = extract_triples_from_chunk(client, chunk, llm_model)
    all_triples.extend(triples)
    print(f"Chunk {chunk['chunk_number']}: {len(triples)} triples extracted")

print(f"\nTotal raw triples: {len(all_triples)}")

```

`

**Example Output:**

```
Chunk 1: 18 triples extracted

Total raw triples: 18

```

***

## **Step 5: Normalization and Deduplication**

Raw triples need cleaning before building the graph:

[kg-normalization1469×1467 168 KB](https://canada1.discourse-cdn.com/flex009/uploads/inovacon/original/2X/c/c0f502a2c25320ce28741b456fde117423febe23.png)

```
def normalize_triples(raw_triples: list) -> list:
    """ Normalizes and deduplicates triples. Steps: 1. Lowercase and trim 2. Filter empty values 3. Deduplicate using Set """
    normalized = []
    seen = set()

    stats = {
        'original': len(raw_triples),
        'empty_removed': 0,
        'duplicates_removed': 0
    }

    for t in raw_triples:
        # Normalize
        s = t.get('subject', '').strip().lower()
        p = t.get('predicate', '').strip().lower()
        p = re.sub(r'\s+', ' ', p)  # Multiple spaces → one
        o = t.get('object', '').strip().lower()

        # Filter empty values
        if not all([s, p, o]):
            stats['empty_removed'] += 1
            continue

        # Deduplicate
        key = (s, p, o)
        if key in seen:
            stats['duplicates_removed'] += 1
            continue

        seen.add(key)
        normalized.append({
            'subject': s,
            'predicate': p,
            'object': o,
            'source_chunk': t.get('chunk', '?')
        })

    print(f"Normalization:")
    print(f" Original: {stats['original']}")
    print(f" Empty removed: {stats['empty_removed']}")
    print(f" Duplicates removed: {stats['duplicates_removed']}")
    print(f" Final: {len(normalized)}")

    return normalized

# Apply normalization
clean_triples = normalize_triples(all_triples)

```

**Example Output:**

```
Normalization:
  Original: 18
  Empty removed: 0
  Duplicates removed: 2
  Final: 16

```

***

## **Step 6: Graph Construction**

With clean triples, we build the graph using NetworkX:

```
def build_knowledge_graph(triples: list) -> nx.DiGraph:
    """ Builds a NetworkX DiGraph from the triples. - Subject → Node - Object → Node - Predicate → Edge label """
    G = nx.DiGraph()

    for t in triples:
        subject = t['subject']
        predicate = t['predicate']
        obj = t['object']

        # add_edge automatically creates nodes if they don't exist
        G.add_edge(subject, obj, label=predicate)

    return G

# Build
kg = build_knowledge_graph(clean_triples)

print(f"Knowledge Graph created:")
print(f" Nodes (entities): {kg.number_of_nodes()}")
print(f" Edges (relations): {kg.number_of_edges()}")

```

**Example Output:**

```
Knowledge Graph created:
  Nodes (entities): 15
  Edges (relations): 16

```

***

## **Step 7: Interactive Visualization**

Using ipycytoscape to render the graph in Jupyter:

`

```
def visualize_kg(G: nx.DiGraph):
    """ Creates interactive visualization of the Knowledge Graph. """
    # Convert to Cytoscape format
    nodes = []
    edges = []

    # Calculate degrees for sizing
    degrees = dict(G.degree())
    max_degree = max(degrees.values()) if degrees else 1

    for node_id in G.nodes():
        degree = degrees.get(node_id, 0)
        size = 20 + (degree / max_degree) * 40
        nodes.append({
            'data': {
                'id': str(node_id),
                'label': str(node_id),
                'size': size
            }
        })

    for i, (u, v, data) in enumerate(G.edges(data=True)):
        edges.append({
            'data': {
                'id': f'edge_{i}',
                'source': str(u),
                'target': str(v),
                'label': data.get('label', '')
            }
        })

    # Create widget
    cyto = ipycytoscape.CytoscapeWidget()
    cyto.graph.add_graph_from_json({
        'nodes': nodes,
        'edges': edges
    })

    # Style
    cyto.set_style([
        {
            'selector': 'node',
            'style': {
                'label': 'data(label)',
                'background-color': '#6366f1',
                'color': '#ffffff',
                'text-valign': 'center',
                'width': 'data(size)',
                'height': 'data(size)',
                'font-size': '10px'
            }
        },
        {
            'selector': 'edge',
            'style': {
                'label': 'data(label)',
                'curve-style': 'bezier',
                'target-arrow-shape': 'triangle',
                'line-color': '#94a3b8',
                'target-arrow-color': '#94a3b8',
                'font-size': '8px',
                'color': '#64748b'
            }
        },
        {
            'selector': 'node:selected',
            'style': {
                'background-color': '#22c55e',
                'border-width': 2,
                'border-color': '#16a34a'
            }
        }
    ])

    # Layout
    cyto.set_layout(name='cose', nodeRepulsion=8000)

    return cyto

# Visualize
widget = visualize_kg(kg)
display(widget)
```

The result is an interactive graph where you can:
- Drag nodes to reorganize
- Click on nodes to select
- Zoom in/out with scroll
- View the relationships (predicates) on the edges

---

## Output Example

For the Marie Curie text, the resulting graph shows:

**Central nodes:**
- `marie curie` (main hub with multiple connections)
- `pierre curie`
- `nobel prize in physics`
- `nobel prize in chemistry`
- `radium`, `polonium`
- `warsaw, poland`

**Typical extracted relationships:**

(marie curie) —[born in]→ (warsaw, poland)
(marie curie) —[discovered]→ (radium)
(marie curie) —[discovered]→ (polonium)
(marie curie) —[won]→ (nobel prize in physics)
(marie curie) —[won]→ (nobel prize in chemistry)
(marie curie) —[married to]→ (pierre curie)
(pierre curie) —[discovered]→ (radium)


`

---

## Complete Code

```python
# kg_pipeline.py - Complete Knowledge Graph Pipeline

import openai
import json
import networkx as nx
import os
import re

def chunk_text(text, chunk_size=150, overlap=30):
    words = text.split()
    chunks = []
    start = 0
    num = 1
    while start < len(words):
        end = min(start + chunk_size, len(words))
        chunks.append({"text": " ".join(words[start:end]), "chunk_number": num})
        start = start + chunk_size - overlap
        if start <= 0: start = 1
        num += 1
        if num > len(words): break
    return chunks

def extract_triples(client, chunk, model):
    SYSTEM = "You are an AI expert in knowledge graph extraction."
    USER = f"""Extract SPO triples from this text as JSON array.
Rules: lowercase, no markdown, concise predicates, resolve pronouns.
Format: [{{"subject": "x", "predicate": "y", "object": "z"}}]

Text: {chunk['text']}

JSON:"""

    try:
        r = client.chat.completions.create(
            model=model,
            messages=[{"role": "system", "content": SYSTEM},
                      {"role": "user", "content": USER}],
            temperature=0.0, max_tokens=4096
        )
        data = json.loads(r.choices[0].message.content.strip())
        if isinstance(data, dict):
            data = next((v for v in data.values() if isinstance(v, list)), [])
    except:
        return []

    return [
        {**t, 'chunk': chunk['chunk_number']}
        for t in data
        if all(t.get(k) for k in ['subject', 'predicate', 'object'])
    ]

def normalize(triples):
    seen = set()
    out = []
    for t in triples:
        key = tuple(t[k].strip().lower() for k in ['subject', 'predicate', 'object'])
        if all(key) and key not in seen:
            seen.add(key)
            out.append({'subject': key[0], 'predicate': key[1], 'object': key[2]})
    return out

def build_graph(triples):
    G = nx.DiGraph()
    for t in triples:
        G.add_edge(t['subject'], t['object'], label=t['predicate'])
    return G

# Main
if __name__ == "__main__":
    client = openai.OpenAI()
    text = "..." # Your text here

    chunks = chunk_text(text)
    raw = [t for c in chunks for t in extract_triples(client, c, "gpt-4o")]
    clean = normalize(raw)
    kg = build_graph(clean)

    print(f"Nodes: {kg.number_of_nodes()}, Edges: {kg.number_of_edges()}")

````

***

## **Next Steps**

This basic pipeline can be extended with:

| **Enhancement**             | **Description**                                     |
| --------------------------- | --------------------------------------------------- |
| **Entity Linking**          | Connect “Marie Curie” and “M. Curie” to the same ID |
| **Relationship Clustering** | Group “born in” and “was born at”                   |
| **Persistence**             | Save to Neo4j or ArangoDB                           |
| **Evaluation**              | Measure extraction precision/recall                 |
| **Multi-hop Queries**       | “What did Pierre Curie’s wife discover?”            |
| **RAG Integration**         | Use the KG to improve LLM responses                 |

***

## **Resources**

* [NetworkX Documentation](https://networkx.org/documentation/stable/)
* [ipycytoscape](https://github.com/cytoscape/ipycytoscape)
* [Neo4j Graph Database](https://neo4j.com/)
* [Knowledge Graphs - Wikipedia](https://en.wikipedia.org/wiki/Knowledge_graph)

***

*Published on yoDEV.dev — The Latin American developers community*