Author Spotlight: Building Real Systems with Mike Huls
Meet Mike Huls - a tech lead working at the intersection of data engineering, AI, and architecture. He helps organizations turn complex data into reliable, usable systems. With a full-stack background, he designs end-to-end solutions that balance technical depth with business value, while sharing practical tools on data platforms, AI systems, and scalable architectures.
The full-stack lens that makes data science useful
Mike sees "full-stack" as understanding how choices in one layer shape behavior, risk, and cost over time - not doing everything yourself. That mindset makes models useful in the real world. A model in a notebook is a starting point. Real value shows up when it's wired into production with pipelines, APIs, governance, and a usable interface.
- Data pipelines that guarantee quality and lineage
- APIs and services for reliable access
- Governance and permissions that match risk
- UIs or integrations where people actually use the output
How he picks what to write and build
He follows recurring friction. If multiple teams hit the same wall, the problem is structural and worth solving at the architectural or process level. He experiments with new tech for its trade-offs, not for novelty. A topic earns attention if it solves an immediate problem or exposes risks people aren't talking about - and if it keeps his interest long enough to go deep.
AI agents: powerful, but not simple
Agents unlock new capabilities, but the biggest misconception is that they're easy. Demos hide the hard parts: state, permissions, cost control, observability, and failure handling. Without clear boundaries and ownership, agents get unpredictable and expensive. They aren't prompts with tools; they are long-lived systems that must be engineered and operated.
- Define scope, roles, and allowed tools up front
- Model state transitions and recovery paths
- Enforce permissions with audit trails
- Set budgets and guardrails for spend
- Instrument telemetry, tracing, and alerts
- Assign clear ownership for upgrades and incidents
For deeper technical context on model-tool integration, see MCP (Model Context Protocol). For engineering and operations patterns, explore AI Agents & Automation.
Layered architecture for small teams
Optimize for change, not just first delivery. Even a lightweight layered approach helps: separate domain logic, application flow, and infrastructure. You don't need perfect boundaries on day one. You need boundaries that let you add features without "open-heart surgery."
- Domain: core rules and transformations
- Application: orchestration, use cases, policies
- Infrastructure: databases, queues, cloud services, adapters
Keep data contracts explicit, push integrations to the edges, and write short decision records so future changes are easier and safer.
"Faster isn't always better" in PostgreSQL
There are pipelines where you should pick the slower, safer path on purpose. If correctness, traceability, and recovery matter more than shaving a few seconds, favor transactional safety and explicit validation. Think regulatory reporting, financial decisioning, or long-lived training datasets that others will build on.
- Use transactions with constraints and unique keys
- Stage-then-merge: validate in a staging table, then upsert
- Idempotency keys to avoid duplicates on retries
- Integrity checks and write-ahead audit logs
Worth a refresher: PostgreSQL transactions.
Why he built a private, self-hosted assistant
Trust drives adoption. Hidden token costs, opaque data flows, and vendor lock-in change how people use systems. By self-hosting, he kept the assistant predictable, auditable, and aligned with European privacy expectations. Users control what it can access, and they can pick models that fit capability, cost, and risk - not just the biggest option.
Curious about agent frameworks? Start with LangGraph to see how stateful workflows come together.
What changes for data pros in 2026
Data and software work is social. The most valuable work happens before code: align with stakeholders, define the problem, and design for how teams actually operate. Agent-assisted development will speed up implementation, but without clear goals and constraints, it multiplies confusion, not output.
- More time on system goals, boundaries, and risks
- Stronger interface contracts and governance
- Proactive validation and drift monitoring in production
- Clear ownership and on-call expectations for AI-enabled services
The big themes to watch this year
Generative AI and agent systems will move from experiments to first-class production. That shift depends on trustworthy, high-quality, accessible data and serious engineering practices. Full-stack thinking and system-level design aren't nice-to-haves - they're how organizations apply AI responsibly and at scale.
Follow Mike's work
To keep up with new articles and projects, follow Mike Huls on LinkedIn.
Your membership also unlocks:
