Sajeer Babu
Software Architect focused on how real systems scale, fail, and evolve, especially at early stages where technical decisions compound quickly.
I think deeply about system design under real constraints and production failures, and the gap between architecture diagrams and reality.
I favor clarity over complexity.
AI systems work
Outside of Toolpack, most of my AI work is training and running models directly, not just calling APIs.
Local inference and retrieval using HuggingFace, Ollama, llama.cpp, vector databases, and RAG
GPU workloads on Kaggle, Google Colab, and Lightning AI for training and pipeline runs
LoRA fine-tuning, with custom model training and diagnostics across precision, optimizer, and gradient settings to reach stable convergence
ComfyUI for building generation pipelines on diffusion models, with controlled, repeatable output
Research & other builds
Alongside Toolpack, a couple of other things I've been building:
KORE (Knowledge-Orchestrated Reasoning Engine)
Fine-tunes Qwen3-1.7B-Instruct with a modified loss function that penalizes reliance on memorized knowledge, using reflection tokens to make the model's reasoning inspectable, benchmarked against FreshQA. Two earlier approaches, a conversational framing and a retrieval-only setup, didn't hold up. This one's further along, still being worked through.
Causal AI
A small fine-tuned reasoning model paired with a structured external knowledge store (a proposition graph of causal relations), running an observe-check-revise reasoning loop instead of leaning on parametric memory. Hit a real wall in relation storage and edge wiring that broke the reasoning chain. Currently paused, not abandoned.
Self-updating memory layer for Bob IDE
Built for an IBM watsonx coding challenge. An MCP server with two-tier staging and memory storage, using the IDE's own file-edit approval flow as the gate for what gets persisted.
Professional Experience
10+ years designing, evolving, and operating production systems across commerce, fintech, developer tooling, and enterprise platforms, with a focus on reliability, operability, and how small architectural decisions compound over time.
Runtime & platform engineering
Contribute to Open Liberty's developer experience tooling: the Liberty Config Language Server (completions, hover docs, and diagnostics for server configuration files), the Liberty Maven and Gradle plugins (ci.maven, ci.gradle, ci.common) for installing, running, and packaging Liberty servers, LSP4Jakarta for Jakarta EE API diagnostics and quick-fixes, and Liberty Tools for IntelliJ IDEA bringing dev-mode support into the IDE. Also built EASeJ, a private YAML Language Server project, since discontinued.
This work sits close to configuration, language tooling, and production operations, where early design decisions often harden into long-term operational constraints.
Commerce & platform engineering
Architected and built commerce platforms at retailcloud over 7 years: a gRPC-integrated microservices platform on GCP, four Angular/Node.js console portals now used by 90% of customers, a multi-tenant platform with Flyway-managed migrations that became one of the company's most revenue-generating solutions, and Stripe payment integration on the customer signup platform. Also contributed to RFID and other back-office systems as the platform evolved.
The work focused on defining service boundaries, clarifying data ownership, shaping operational workflows, scaling infrastructure, identifying where integrations failed under real usage patterns, and keeping the platform operable as business and technical complexity increased.
Banking & offline systems
Banking automation systems shaped by regulatory constraints, offline operation, and strict failure-recovery requirements. An early influence on how I think about operational discipline and the gap between planned system behavior and production reality under stress.
Curated notes
Much of my thinking comes from noticing where early-stage systems tend to drift, how assumptions break under real usage, how responsibilities blur as teams grow, and how small design decisions compound in production.
Topics I speak on
Designing systems that survive early growth
Focuses on architectural decisions that hold up under rapid change - imperfect requirements, small teams, and the realities of scaling before systems are fully understood.
Architecture trade-offs in real production environments
Explores how real-world constraints shape system design, and why many "best practices" need to be re-evaluated once systems face production load and operational pressure.
How AI changes developer workflows in practice
Looks at where AI genuinely helps developers today, where it creates friction, and how teams adapt when AI becomes part of everyday engineering rather than a novelty.
