Forem: Guillermo Mejia

Why I’m Betting on Zig for Backend Development

Guillermo Mejia — Fri, 06 Mar 2026 19:42:27 +0000

The Shift from High-Level to Low-Level

After years in managed ecosystems, I recently started switching my backend development to Zig. The catalyst? Leveraging AI as a pair-programmer has made "low-level" development feel as easy as high-level. With quick knowledge access and debugging assistance, the traditional barriers to manual memory management are fading, leaving only the massive performance benefits.

Architecture: The Modular Monolith

As a solo developer, jumping straight into microservices is often an invitation to infrastructure nightmares. Instead, I’ve adopted a Vertical Slicing approach within a single Zig project.

By using Zig libraries to isolate features into their own modules, I maintain a clean separation of concerns. This allows the code to stay maintainable today, while being "extraction-ready" for a future RPC-based microservices architecture tomorrow.

The "Batteries-Not-Included" Advantage

Zig web development is undeniably manual. You won’t find a "Spring Boot" or "Next.js" here. I’m currently writing my own Database Abstraction Layer with a custom query builder and migration/seeding scripts.

Using Tokamak has significantly eased nested routing, grouping, and middleware integration. It’s a testament to the growing Zig ecosystem that even a solo-dev project like Tokamak -which is under active, rapid development- can provide such a streamlined experience. This "developer-to-developer" support is a hallmark of the Zig community; we aren't waiting for massive corporate frameworks. Instead, we are building focused, high-performance tools that prioritize clarity over magic. Seeing that level of passion from other developers makes the "manual" nature of Zig web-dev feel less like a chore and more like a collective effort to reclaim control over the stack.

Why it's Worth the Time

The syntax simplicity of Zig is its greatest strength. There is no hidden control flow and no hidden allocations. While it takes longer to set up the initial "plumbing," you are building a long-running platform that avoids the technical debt and "black box" behavior of high-level frameworks. You gain full control over every resource your application touches.

Built with Google Gemini: Humanizing the Helpdesk with Warm AI

Guillermo Mejia — Wed, 04 Mar 2026 16:47:04 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

I built a modular agent orchestration platform designed to humanize automated support. While many AI bots feel transactional and cold, my project focuses on "warmth"—using Gemini 2.5 Flash to create empathetic, context-aware interactions that feel like talking to a helpful peer.

The platform uses a specialized adapter system to deploy versioned conversational flows. Whether it is a car dealership agent qualifying a lead or an internal assistant helping a developer navigate complex node-based logic, Gemini handles the reasoning and tone. The "warmth" is evident in the transitions; instead of a generic "I still need a few more details: car mileage, general condition," the bot asks, "What is the mileage and condition of your 2020 Elantra?"—directly referencing the user's specific context with a natural touch.

Demo

The demo showcases two distinct Telegram-integrated use cases:

Automotive Sales Lead: Intelligently qualifies leads by asking for missing details (mileage, condition) in a conversational manner.
Platform Navigator: A RAG-powered assistant that explains internal flows, nodes, and edges (using ng-diagrams) to help users understand their agent structures.

What I Learned

MFE Architecture: Implementing Angular 21 with Native Federation v2, PrimeNG, and Tailwind CSS allowed for a highly modular frontend where different agent types are managed independently.
Vectorized RAG: Integrating Supabase (pgvector) for long-term memory and restricted content delivery within agent flows, managed through Vercel's AI SDK.
The "Warmth" Prompt: I learned that achieving a human-centric tone is about using Gemini’s reasoning to bridge the gap between structured data (like car specs) and natural prose.
Edge Performance: Deploying on Vercel Edge Functions provided the low latency required for real-time Telegram webhooks.

Google Gemini Feedback

FinOps & Efficiency: A major highlight was the cost-to-performance ratio. Using text-embedding-001 with 3072 dimensionality provided high semantic accuracy, yet running over 170+ requests (Gemini Flash + Embeddings) during an 8-hour development sprint cost only about $0.10.
Developer Experience: The Google AI Studio integration was incredibly straightforward. The reasoning capabilities of Gemini 2.5 Flash allowed the bot to handle complex lead qualification without losing its "warm" persona.
Friction Points: Balancing empathy with brevity on platforms like Telegram requires significant prompt-tuning. More native support for "persona" weighting within the SDK would be a welcome addition.

Beyond the Prototype: Lessons from Atom Dev Day Guatemala

Guillermo Mejia — Tue, 03 Mar 2026 22:55:12 +0000

This past weekend was a transformative experience. I participated in Atom Dev Day, and while my project did not reach a competition-ready state by the deadline, I walked away feeling fortunate for the opportunity.

Sometimes, the real value of a hackathon is not the final pitch, but the process of being pushed back into the deep end and discover new ways of challenging yourself.

Stepping Out of the Comfort Zone

Beyond the lost sleep, this event served as a vital reminder to step out of my comfort zone. It reignited my hunger for exploration in a landscape where emerging technologies grow faster than we can experiment with them.

Working with Machine Learning and LLMs is a constant reminder of how transformative these tools are. When harnessed correctly, they offer a multitude of possibilities across diverse markets, accelerating and easing processes that used to be significant bottlenecks.

Atom: Bridging the Future in Latin America

I want to extend a massive thank you to the Atom team. They are leading the charge across Latin America, bridging geographical borders and with the future.

It is exactly this kind of organization that makes a bright, tech-driven future accessible to audiences of every kind, regardless of technical knowledge. The quality of the event they organized in such a short timeframe was world-class.

The Talent in Guatemala

A major highlight was the talent gathered in one room. The Guatemalan software community is thriving, spanning all ages and experience levels. The energy was proof that the talent and experience exist here in abundance and it's amazing how companies like Atom jump in and empower it to showcase what we can achieve.

Final Thoughts

This weekend was a wake up call to keep building at the edge of what is possible. My prototype is just the beginning, and I am grateful to Atom for providing the spark.

From Zero to Monorepo: Angular v21 MFE with Native Federation

Guillermo Mejia — Tue, 17 Feb 2026 05:01:32 +0000

Welcome! In this guide, we'll walk through how to set up an Angular 21 application using a micro frontend architecture. We'll be using the awesome Angular Architects' Native Federation package to make this happen.

What are Micro Frontends?

Think of micro frontends like building with LEGO. Instead of one giant, heavy block, you build several smaller, independent pieces (the "micro" parts) that fit together to make one big application (the "frontend"). This makes it much easier for different teams to work on different parts of the app without stepping on each other's toes.

Native Federation uses features already built into modern browsers (native module federation) to handle this, which makes it fast and future-proof!

Prerequisites

Before we dive in, let's make sure your toolbox is ready. You'll need:

Node Version Manager (nvm): This is like a switcher for different Node.js versions. It's super helpful if you work on multiple projects!
Node.js and npm: You'll need the latest LTS (Long Term Support) version that's compatible with Angular 21.
Angular CLI: This is our command-line buddy that helps us generate code and run our app.

To install the Angular CLI, just run this command in your terminal:

npm i -g @angular/cli

Step 1: Set up Your Workspace (Monorepo)

First, let's create a special workspace called a "monorepo." A monorepo is just a fancy way of saying "a folder that holds many related projects."

We'll use a special flag, --create-application=false, which creates a clean slate without an initial app, so we can carefully add our own later.

ng new mfe-spa --create-application=false
cd mfe-spa

Step 2: Create Your Applications

Now, inside our workspace, we'll create two main types of apps: the Shell (Host) and the Micro Frontend (Remote).

The Host Application (The Shell)

Think of the host as the "frame" or "shell" that ties everything together. It's the main app that users load first.

ng g application host

The Remote Application (The Micro Frontend)

The remote application is the specific piece of functionality (like a profile page or a dashboard) that will live within the host. You can call it whatever you like!

ng g application my-remote-app

(Feel free to replace my-remote-app with your own name!)

Step 3: Add Native Federation

Now, let's install the magic that makes it all possible! This package will help us share components and modules between apps.

npm install @angular-architects/native-federation -D

Step 4: Give Your Apps a Micro Frontend Boost!

Now, we need to run a special "initialization" command for each of our apps. This will prepare them to talk to each other.

Preparing the Host

Run this command to tell our host app that it will be looking for micro frontends.

ng g @angular-architects/native-federation:init --project host --type host --port 4200

What this does: It configures the host as the "shell" (the consumer) and sets it to run on the standard development port (4200).

Preparing the Remote

Now we'll do something similar for our remote app (replace my-remote-app with the name you chose).

ng g @angular-architects/native-federation:init --project my-remote-app --type remote --port 4201

What this does: It configures our remote app to be a "provider" (something the host can borrow) and sets it to run on a different port (4201) so they don't fight over the same port!

Configuration Magic (Post-Initialization)

Now that we've set up the foundations, we just need to tell each app what it's sharing and what it's receiving!

1. In the Remote App: Choose What to Share

In your remote app's module-federation.config.ts, you decide which components or modules are "exposed" (available to be borrowed by the host).

// projects/my-remote-app/module-federation.config.ts
export default {
  name: 'myRemoteApp',
  exposes: {
    // We name it './Component' so the host knows how to find it!
    './Component': './projects/my-remote-app/src/app/my-remote-component/my-remote-component.component.ts',
  },
};

2. In the Host App: Find Your Remotes

In your host app's module-federation.config.ts, you tell the host where to look for your micro frontends.

// projects/host/module-federation.config.ts
export default {
  name: 'host',
  remotes: [
    {
      // The name should match the name in the remote's config!
      name: 'myRemoteApp',
      url: 'http://localhost:4201/remoteEntry.json',
    },
  ],
};

3. Loading the Remote Dynamically!

The coolest part! In your host app's routing configuration, you can use loadRemoteModule to load your remote component only when the user needs it.

// projects/host/src/app/app.routes.ts
export const routes: Routes = [
  {
    path: 'my-feature',
    loadComponent: () => 
      loadRemoteModule('myRemoteApp', './Component').then((m) => m.MyRemoteComponentComponent),
  },
];

Conclusion: You Did It!

Congratulations! You've just set up a modern, scalable micro frontend architecture using Angular 21 and Native Federation. This foundation makes it easy to keep your projects organized as they grow and helps you stay on the cutting edge of web development.

Happy coding!