AI-DNA Software Tech Lead

Enterprise software portfolios age in predictable ways: security vulnerabilities accumulate across unpatched installers, platform migrations stall without an owner, legacy SDK dependencies block entire product lines, and the engineers who could fix these things are busy shipping features elsewhere. This role exists to hold the technical bar across the GFI product portfolio — spanning network security, email infrastructure, WAN optimization, cloud archiving, and endpoint management — and to make sure the hardest problems get diagnosed correctly, directed to the right fix, and shipped to customers.

The issues that reach this role dont live at the application layer. They live in how a Linux daemon interacts with the kernel memory subsystem, how a backup agent corrupts a live database, how a protocol parser misbehaves under concurrent load, or how a Windows service installer propagates permissions it shouldnt. An engineer who understands the system model directs the right fix in one cycle. A fix that never makes it into a release build is not a fix.

What You Will Be Doing

• Evaluate AI-generated triage drafts for technical accuracy, confirm or correct severity assessments, and ensure every issue reaches a coding agent with a clear reproduction path and correctly scoped fix prompt. Review AI-generated PRs against the underlying system model, not just the diff.
• Direct the technical work of engineers and contractors across the portfolio — scoping fixes, reviewing approaches, and holding the quality bar before code merges.
• Own the fix lifecycle for escalations requiring your depth — across OS/kernel behavior, database internals, network protocol correctness, Windows security architecture, or cloud API migration. Deliver merged, production-ready PRs that land on the right branch and clear the release pipeline.
• Track platform deadlines, surface architectural risks ahead of the customer-impact window, and drive cross-product dependency decisions — vendor SDK upgrades, deprecation migrations, security hardening — that fall outside any single product teams scope.
  
  

What You Will NOT Be Doing

• Waiting for work to come to you. The escalation layer surfaces and structures issues — but proactively identifying patterns, risks, and architectural gaps before they become customer-impacting events is part of the job.
• Writing code in isolation. Your output is reviewed, AI-assisted PRs that ship — not explorations or WIP branches.
• Owning only one product. The portfolio escalates as a unified surface. Switching between a database locking problem and a mesh networking issue in the same week is not unusual — it is the job.
• Treating kernel, protocol, or security domains as areas to route around. The hardest escalations live exactly there.
• Considering a PR merged as a fix delivered. A fix is delivered when it is in a release build a customer can install.
  
  

Requirements

• AI-fluent engineering — daily Claude Code or Cursor use, not experimentation. You write prompts that produce mergeable PRs; you evaluate AI-generated code at the system level. The higher bar is multiplication: you encode your system-model depth back into the agents — context files, rules, self-verification harnesses — so each class of escalation needs progressively less human intervention over time, not just review at 1:1 throughput.
• Systems-level OS knowledge — you understand how software interacts with the kernel, scheduler, and memory subsystem; application-layer symptoms rarely tell you what is actually broken, and you know where to look.
• C/C++ systems programming — you have built or debugged production software in C or C++; you use gdb, core dumps, and sanitizer builds as standard tools, not last resorts.
• Tech lead experience — you have directed the work of other engineers or contractors in a complex software environment; you set direction and review work, not just produce it.
• Proactive ownership — you surface problems before they are escalated to you; you run cross-layer root cause analysis on hard failures, including diagnosing why existing rules or agents missed them.
  
  

Nice to Have

• Prior experience with any product in the GFI/Kerio portfolio
• Published writing, talks, or open-source contributions in any of the domains above
• Go concurrency experience: goroutine lifecycle, channel coordination, race detector output
• Microsoft 365 hybrid deployment experience at scale
  
  

What You Will Learn

The GFI portfolio is a live cross-section of systems software, network security, email infrastructure, and cloud platform migration at enterprise scale. Engineers operating here develop systems breadth that purpose-built product teams rarely see. The AI-first triage layer is already in production — you will define what it means to encode system-model depth into those agents, making the whole system sharper over time rather than just keeping pace with it.

Working Conditions

Fully Remote, Async-first, Global. No Office. The Team Is Lean And Senior — You Will Direct The Work Of Engineers And Contractors Without a Dedicated Escalation Layer Beneath You. The Week Divides Roughly Across Triage And Review, Active PR Contribution, And Proactive Lifecycle Management — With The Balance Shifting Toward Wherever The Load Demands. Outcomes Are Defined Explicitly And Measured Weekly

• Clean releases — fixes reach a customer-installable build and hold there; no regressions, no reopened escalations.
• Multiplying agents — every escalation you handle makes the AI system sharper; human-required escalations trend down over time, not sideways.
• Standards enforced — the work the team directs ships to our engineering standards and clears quality gates first-pass, consistently.
• Risks surfaced early — architectural risks flagged ahead of the customer-impact window, not after it.
  
  

No token limits. No tooling limits. If the right answer is a better model, a different agent configuration, or a tool not yet in the stack, that conversation is always open.

---