Enterprise IT leadership · solution architecture · full-stack delivery · AI automation

Pol Balatbat

Technology Leader · Head of IT · Solutions Architect · Full-Stack Developer · AI Automation Engineer · Agentic Engineer

I work at the seam between enterprise IT leadership and hands-on engineering: twenty years running operations, infrastructure and vendors across Dubai and Qatar, and now architecting and building cloud-native systems, progressive web apps and AI automation.

View projects Download CV Contact me

How the work connects

  1. Leadership
  2. Architecture
  3. Cloud
  4. Full Stack
  5. AI / Agentic

01 — Who I am

Leadership and background

Two decades of international IT work, in two distinct halves.

I started in the field. From 2005 to 2011 I worked in IT in Dubai — systems administration, network and server infrastructure, and the day-to-day operational support that teaches you how enterprise environments actually behave under load, under change, and under pressure.

From 2011 to 2024 I was in Qatar in IT leadership roles, as Head of IT and IT Manager. The work moved from configuring systems to owning them: enterprise IT operations, infrastructure and network strategy, vendor and contractor management, business continuity, cost optimization, and leading projects through to handover. Decisions there were measured in budget, downtime and risk rather than lines of code.

Since then I have moved deliberately back toward building. I design and implement solutions end to end — solution and software architecture, full-stack development, Cloudflare-centric cloud infrastructure, and AI-assisted and agentic engineering workflows where multiple coding agents work under human review.

The leadership years are why I architect the way I do. I have carried the pager for systems I signed off on, negotiated with the vendors, and justified the invoice — so I design for operability, cost and continuity first, and reach for complexity only when the requirement genuinely demands it.

02 — Capability

Core competencies

Where the enterprise and engineering sides of the work overlap.

Enterprise IT leadership

  • Head of IT
  • IT operations
  • Technology strategy
  • IT infrastructure
  • Vendor management
  • Contractor management
  • Project leadership
  • Business continuity
  • Cost optimization

Solution & software architecture

  • Solution architecture
  • Software architecture
  • API architecture
  • Security design
  • Role-based access control
  • System integration
  • Scalable application design

Full-stack engineering

  • TypeScript
  • JavaScript
  • Python
  • React
  • Next.js
  • Node.js
  • SQL
  • REST APIs
  • Progressive Web Apps

Cloud & infrastructure

  • Cloudflare Pages
  • Cloudflare Workers
  • Cloudflare D1
  • Cloudflare R2
  • Durable Objects
  • Cron Triggers
  • VPS administration
  • Linux
  • DNS & reverse proxy

AI & automation

  • Agentic engineering
  • AI coding agents
  • Claude Code
  • OpenAI Codex
  • Multi-agent workflows
  • Structured prompting
  • AI-assisted development
  • Workflow automation
  • Human-in-the-loop engineering

03 — Work

Selected projects

Four systems that between them cover multi-role operational software, agentic engineering workflows, real-time communications and long-lived data platforms. Each entry below was checked against its own repository and its live deployment.

The GORA public site at goranaservices.com: a headline reading “Arayat is about to move differently”, an illustration of a delivery rider, and two call-to-action buttons.

Project 01

GORA

Multi-role delivery platform · Progressive Web App

Live landing · app in staging

A local delivery platform for Arayat, Pampanga that replaces a Facebook-and-Messenger ordering workflow with structured software. Not a single ordering screen: customers, stores, riders, courier companies and dispatch each get their own operational surface over one authorization model.

Languages

  • TypeScript
  • TSX
  • SQL
  • JavaScript

Stack

  • React 19
  • Vite
  • Tailwind CSS
  • Cloudflare Pages
  • Cloudflare Workers
  • Hono
  • Cloudflare D1
  • Cloudflare R2
  • Cron Triggers
  • JWT (jose)
  • Web Push (VAPID)
  • PWA
Open GORAProduction Staging previewStaging · private team test
My role
Solution architect and full-stack developer — data model, authorization design, settlement architecture and implementation across frontend, API and database.
Problem
Local delivery needs every participant working from the same state at the same time, on whatever phone they already own, with cash on delivery as the default and no per-seat software cost. The hard part is not the ordering screen; it is keeping money, custody and accountability straight once an order fails, is modified, or is handed between a rider and a courier company.
Architecture
A React Progressive Web App on Cloudflare Pages talking to a Hono API on Cloudflare Workers, with Cloudflare D1 as the relational store and R2 for images. Roles and permissions are resolved server-side on every request. Staging and production are fully separate Worker environments with their own databases, buckets and secrets; the production environment is deliberately held inert until an explicit activation step.

Engineering decisions

  • A PWA rather than native apps, so riders and store staff install from a URL and updates ship without app-store review.
  • Authorization resolved server-side per request from the session role — the client never decides what it is allowed to do.
  • Settlement, remittance and failed-delivery custody modelled explicitly, with maker-checker separation so the person who raises a financially sensitive action is not the person who approves it.
  • An append-only activity and audit trail that snapshots the actor role at event time, so a later rename or role change cannot rewrite history.
  • A scheduled Cron Trigger sweeps for rider-assignment delays every minute; idempotency is enforced in the database so a retried invocation cannot double-notify.
  • Edge-native and serverless throughout, which keeps fixed running cost near zero while the platform scales with demand.

Security considerations

  • JWT sessions with a per-user token-version counter, so sessions can be invalidated server-side.
  • Google sign-in verified against Google’s public certificates only — no service-account key or Admin SDK credential in the application.
  • Separation of duties on settlement and payout actions; least privilege per role.
  • Staging and production hold separate secrets; production secrets are never copied from staging.
The Relay desktop application: a project profile and agent-roles panel, agent health and usage-protection settings on the left, and a run history listing eighteen completed workflow runs on the right.
Screenshot of the application; local filesystem paths redacted.

Project 02

Relay

Application — AI workflow automation for agentic software engineering

Private application

A desktop application that runs an Architect → Worker → Review loop over installed AI coding agents. It is the workflow around the agents, not another chat window: the application selects the engines, writes the prompts, reads back the output, decides whether the iteration passed, and stops for a human when a decision is consequential.

Languages

  • Python

Stack

  • Python 3.11+
  • PySide6 (Qt)
  • PyInstaller
  • Claude Code CLI
  • OpenAI Codex CLI
  • Local subprocess orchestration
  • Atomic JSON state
  • SHA-256 content hashing
  • Windows desktop
Request access to RelayPrivate — no public URL
My role
Architect and developer — the orchestration model, the state machine, the prompt and handoff contracts, and the desktop application itself.
Problem
A single AI coding agent in a chat window is unrepeatable. Context is lost between sessions, nothing reviews the work, and afterwards there is no record of what was done or why. Treating the agents as subprocesses inside a state machine is what makes the output reproducible and auditable.
Architecture
A Python desktop application that drives already-installed coding-agent CLIs as local subprocesses — it holds no model API client and asks for no API keys. Each project gets a workspace directory holding the authoritative instructions, the current prompt and output, versioned workflow state and a run history. State is written through a flushed temporary file and an atomic replace, and a SHA-256 content hash of the Worker output prevents the same unchanged result from being reviewed twice. It packages to a standalone Windows application.

Engineering decisions

  • Architect and Worker responsibilities split across separate engine invocations — and across separate providers where that helps — so planning is not done by the pass that writes the code.
  • The source-of-truth instruction file is never overwritten by the application — only read, hashed and referenced.
  • Versioned, atomically written workflow state carrying the instruction hash, assigned engines, iteration ceiling, consecutive-failure limit and prompt/output hashes, so an interrupted run resumes instead of restarting.
  • An immutable per-run iteration history: every iteration records its prompt, its output and the Architect review of that output, under a run identifier that does not change.
  • A content hash on Worker output, so an unchanged result cannot consume a review iteration.
  • Optional deterministic release gates — a final test command that must pass, and a clean-working-tree requirement — so "complete" is a measured result rather than an agent’s opinion.
  • Usage protection against the provider allowances: warn and stop thresholds per engine, and a policy for what happens when an allowance runs low rather than a failed run.
  • Controlled autonomy: the loop runs unattended, the consequential steps do not. A NEEDS_USER state stops the workflow and waits for the owner.

Security considerations

  • No model API keys, no third-party model client, no credential storage — the installed CLIs own their own authentication.
  • Credential redaction in the activity streams the application displays.
  • Workspace-isolated navigation that refuses a foreign or executable path and never goes through a shell.
  • Human approval retained for consequential and irreversible steps.
The Magchatka staging sign-in screen: the Magchatka wordmark beside chat-bubble artwork, with an email and password form and a Google sign-in option.

Project 03

Magchatka

Real-time communications application · PWA and mobile

Staging preview

Messaging, voice and video in one application — delivered as an installable PWA and wrapped as Android and iOS builds from the same codebase. Real-time state runs on Cloudflare Durable Objects; calls run peer-to-peer over WebRTC with a self-hosted relay for the networks where direct peering fails.

Languages

  • TypeScript
  • TSX
  • SQL

Stack

  • React 19
  • Vite
  • Capacitor (Android / iOS)
  • Cloudflare Workers
  • Hono
  • Durable Objects
  • Cloudflare D1
  • Cloudflare R2
  • WebRTC
  • coturn (STUN / TURN) on VPS
  • FCM push
  • PWA
Open Magchatka previewStaging / preview — sign-in required
My role
Architect and full-stack developer — signalling design, call lifecycle, presence and reconnection model, and the TURN relay infrastructure.
Problem
Real-time calling in the browser is mostly an infrastructure problem. Peer-to-peer media is cheap and low-latency once it connects, but NAT traversal, signalling, presence across multiple devices, and what happens when a phone changes network or the app is backgrounded are where real implementations fail.
Architecture
A React client on Cloudflare Pages, a Hono API on Cloudflare Workers, and Durable Objects holding the live state: one coordinates chat rooms, another coordinates call sessions, both over hibernatable WebSockets so idle connections cost nothing. D1 stores messages and accounts, R2 stores photos. Media is WebRTC peer-to-peer, falling back to a self-hosted coturn TURN server on a VPS with short-lived credentials minted by the Worker. Capacitor wraps the same build as Android and iOS applications.

Engineering decisions

  • Durable Objects with WebSocket hibernation for live state — a single authoritative coordinator per room or call, and no cost for idle sockets.
  • Peer-to-peer media by default with TURN relay only as the fallback path; both latency and relay cost drop when direct connections succeed.
  • TURN credentials minted server-side with a short time-to-live rather than shipped in the client.
  • Presence delivered as real-time deltas instead of directory polling, after polling proved to be the dominant source of idle traffic.
  • Explicit handling for the cases that actually break calls: network handoff mid-call, socket supersession, multi-device presence, and reconnect-and-resume.
  • One codebase for web, Android and iOS through Capacitor, rather than three clients to keep in step.

Security considerations

  • Authenticated sessions before any socket or call can be established.
  • TURN and signalling credentials held server-side and issued with a short expiry; no infrastructure secret reaches the client.
  • WebRTC transport encryption (DTLS-SRTP) is mandatory in the protocol and relied on as such.
  • Staging runs as an isolated Worker environment with its own database, bucket and origin allow-list.
The MBN Collection archive interface: a “Private Collection” heading above category tabs, faceted filters for designer and colour, and a grid of catalogued wardrobe pieces.

Project 04

MBN Collection

Private collection and inventory platform

Private · authenticated

A private luxury wardrobe archive of roughly six thousand catalogued pieces, carried off a legacy WordPress and MySQL stack onto a modern edge platform without losing the dataset. Faceted search across category, designer, colour and collection, with the images served from object storage.

Languages

  • TypeScript
  • TSX
  • SQL
  • PHP (legacy)

Stack

  • Next.js 15
  • React 19
  • Tailwind CSS
  • Framer Motion
  • OpenNext on Cloudflare
  • Cloudflare Workers
  • Cloudflare Pages
  • Cloudflare D1
  • Cloudflare R2
  • WordPress / MySQL (legacy)
View MBN CollectionSign-in required Request access to MBN Collection
My role
Owner, architect and developer across the lifetime of the system — the original platform, the data analysis, the migration design and the current application.
Problem
Collection data outlives the software that holds it. The original system was WordPress, PHP and MySQL on shared hosting, holding roughly ten thousand images and the inventory records attached to them. The engineering problem was continuity: keeping the catalogue intact, searchable and useful while the platform underneath it was replaced piece by piece.
Architecture
A Next.js application deployed to Cloudflare through the OpenNext adapter, with Cloudflare D1 as the inventory database and R2 for the wardrobe media. The migration runs as tooling rather than a one-off: scripts scan the legacy assets, upload what is still pending, and seed the inventory, so the move is repeatable and can be verified against the old system instead of trusted.

Engineering decisions

  • Incremental modernization over a rewrite, so the dataset is never put at risk for the sake of a new stack.
  • The data model treated as the durable asset and the interface as the replaceable part.
  • Migration implemented as re-runnable scripts with a scan-then-upload split, so it can be checked and resumed rather than performed blind.
  • Images moved to object storage and served from the edge, which is what makes a six-thousand-item grid usable.
  • Private by default — the collection sits behind authentication, because its contents are not for publication.

Security considerations

  • The application is behind authentication; the public URL opens a sign-in gate, not the catalogue.
  • The legacy system was left intact and read-only during migration rather than modified in place.
  • No collection record, image or owner detail is published through this portfolio.

04 — Track record

Career timeline

A summary, not a CV — the CV carries the detail.

  1. Current

    Solution architecture, full-stack engineering, AI automation

    Independent

    Designing and building cloud-native systems and Progressive Web Apps end to end on Cloudflare infrastructure. Working in AI-assisted and agentic engineering workflows — multiple coding agents under structured prompts, cross-review and human approval.

  2. 2011 – 2024

    Head of IT / IT Manager

    Qatar

    Thirteen years owning enterprise IT. Operations, infrastructure and network strategy, vendor and contractor management, business continuity planning, cost optimization, and leadership of technology projects from requirement through handover.

  3. 2005 – 2011

    IT infrastructure and systems

    Dubai

    Six years hands-on in enterprise environments: systems administration, server and network infrastructure, and operational support. The grounding the later architecture work is built on.

05 — Approach

How I work

Six positions I will defend in a design review.

The business problem comes first

Requirements before architecture, architecture before code. Most systems that fail technically were answering the wrong question correctly.

Security by design, least privilege by default

Authorization decided server-side, permissions scoped to the task, separation of duties wherever money or irreversible actions are involved. Retrofitted security is rarely security.

Humans stay in the loop on AI

Agentic workflows are genuinely productive and should still not hold the approval. I automate the loop and keep the consequential decision with a person.

Technology chosen against requirements, not trends

A static page, a Worker and a SQL table solve more problems than they are given credit for. I add a framework when the requirement earns it.

Operability, reliability, maintainability

Someone runs this on a Sunday, and sometimes that someone is me. Staged deployment, tested before production, and understandable by the next engineer.

Cost is an architectural constraint

Infrastructure spend is a design input, not an invoice that arrives later. Edge-native and serverless architectures hold capability high and fixed cost near zero.

06 — Get in touch

Contact

For architecture review, IT leadership, full-stack delivery or AI automation work — call, email, or reach me on any of these. A short note about the problem is the most useful thing you can send.

Download CV

Messages go straight to me; nothing is stored by this site and there is no form to fill in.