TK
Talik Kasozi
Production Systems & Edge Architecture

Sub-millisecond systems, edge functions & security gatekeepers.

I build high-performance software where reliability and latency are non-negotiable. From bare-metal x86_64 operating systems in Rust to sub-0.8ms Shopify WebAssembly checkout extensions, AST static analysis PR gatekeepers, and distributed Kubernetes microservices.

< 0.8ms
Edge Execution
0.0 KB
Client Runtime Bloat
x86_64
Bare-Metal Rust OS Kernel
C++ / Qt
Native Desktop Architecture

01 / Two Perspectives, One Standard of Rigor

Whether evaluating for commercial return on investment (speed, conversion, zero downtime) or for staff-level engineering depth (low-level concurrency, compiler mechanics, memory safety), every project below is backed by running production code and architectural case studies.

Commercial ROI ⇄ Systems Depth
Production Fleet

Architectural Case Studies

Production App Store #01

EdgeWholesale: Native B2B & Wholesale Engine

Production Shopify App on the Shopify App Store

Commercial Impact & ROI

Eliminated the need for a $2,000/mo Shopify Plus contract for merchants requiring B2B wholesale tiered discounts and MOQ validation.

Technical Architecture

Engineered in pure Rust compiled to WebAssembly (wasm32-wasip1). Executes directly on Shopify's global edge infrastructure during checkout in < 0.8ms, injecting 0.0 KB of theme JavaScript to preserve Google Core Web Vitals.

Edge Execution
< 0.8ms
Theme JavaScript
0.0 KB
Architecture
Rust / Wasm
Auth Model
OTP / Classic
Rust WebAssembly Remix v2 Shopify Functions Polaris SQLite Docker
systems_core
read_only
// Pure Rust Wasm discount evaluator (<0.8ms execution)
#[shopify_function_target(query_path = "src/run.graphql")]
pub fn run(input: input::ResponseData) -> Result<output::FunctionRunResult, Box<dyn Error>> {
    let customer_tags = input.cart.buyer_identity.as_ref()
        .and_then(|b| b.customer.as_ref())
        .map(|c| &c.tags);
    // Zero external DB latency - executed synchronously inside edge Wasm sandbox
    Ok(calculate_tiered_discounts(input.cart.lines, customer_tags))
Verified Architecture 100% Deterministic
Systems Kernel #02

Buraq OS: Bare-Metal x86_64 Operating System

Custom Rust Kernel Built From Scratch

Commercial Impact & ROI

Demonstrates foundational mastery of CPU architecture, memory models, and deterministic concurrency without standard library safety nets.

Technical Architecture

Custom x86_64 hobby kernel written in Rust (no_std). Implements Global Descriptor Table (GDT) with TSS/IST stack switching for double fault recovery, Interrupt Descriptor Table (IDT), PIC 8259 hardware interrupt controller, PS/2 keyboard driver, lock-protected Bump Allocator, and direct VGA framebuffer graphic console.

Target
x86_64-unknown-none
Memory Model
Bump / Paging
Interrupts
PIC 8259 / IDT
Display
VGA Framebuffer
Rust x86_64 no_std OS Dev Bootloader Concurrency Assembly
systems_core
read_only
// Interrupt-safe print macro wrapped in deadlock-prevention spinlock
#[macro_export]
macro_rules! print {
    ($($arg:tt)*) => ($crate::drivers::screen::_print(format_args!($($arg)*)));
}

pub fn init_interrupts() {
    gdt::init();
    idt::init_idt();
    unsafe { PICS.lock().initialize() };
    x86_64::instructions::interrupts::enable();
}
Verified Architecture 100% Deterministic
Native Desktop (C++/Qt) #03

Buraq: C++ & Qt Native Code Editor

Specialized Scripting & Systems Editor with vcpkg & SAST

Commercial Impact & ROI

Engineered high-performance native desktop software avoiding heavy Chromium/Electron runtimes, delivering sub-10ms keystroke response and minimal RAM consumption.

Technical Architecture

Engineered in modern C++ with the Qt GUI framework (qtbase via vcpkg, CMake). Implements custom syntax highlighting engines, low-latency line numbering viewport widgets, file system traversal, PVS-Studio SAST verification, and multi-tab document buffer management.

GUI Framework
C++ / Qt
Package Tool
vcpkg / CMake
Static Analysis
PVS-Studio
Syntax Engine
Custom QSyntax
C++ Qt CMake vcpkg PVS-Studio Desktop GUI Cross-Platform Performance
systems_core
read_only
// Custom Qt C++ syntax highlighter rule evaluator
void CodeEditorHighlighter::highlightBlock(const QString &text) {
    for (const HighlightingRule &rule : highlightingRules) {
        QRegularExpressionMatchIterator it = rule.pattern.globalMatch(text);
        while (it.hasNext()) {
            QRegularExpressionMatch match = it.next();
            setFormat(match.capturedStart(), match.capturedLength(), rule.format);
        }
    }
}
Verified Architecture 100% Deterministic
CI/CD & Agensi.io Skill #04

Edge Guardian: AST CI/CD Gatekeeper for Shopify Apps

Automated Policy & Security PR Audit Engine

Commercial Impact & ROI

Protects Shopify app developers from the 7–14 day review rejection penalty by proactively catching scope bloat, credential leaks, and non-compliant code.

Technical Architecture

AST static analysis engine inspecting TypeScript/Remix syntax trees in GitHub Actions and Docker. Audits least-privilege Shopify scopes, detects hardcoded secrets, validates GDPR webhook endpoints, and packaged as an autonomous AI agent skill for Agensi.io.

Audit Gates
5 Automated
CI/CD Runtime
< 12s
Integration
Docker / Agensi
Scope Model
Zero Bloat
TypeScript AST Analysis Docker GitHub Actions CI/CD Security AI Skills
systems_core
read_only
// AST visitor enforcing least-privilege Shopify access scopes
export class ScopeValidatorVisitor extends BaseASTVisitor {
  visitScopeDeclaration(node: ScopeASTNode): void {
    const forbidden = ["read_all_orders", "write_products"];
    if (node.scopes.some(s => forbidden.includes(s))) {
      this.addViolation("CRITICAL_SCOPE_BLOAT", "Principle of least privilege violated.");
    }
  }
}
Verified Architecture 100% Deterministic
Distributed Fleet #05

Bizaura Security Core & Sentinel Agents

Distributed K8s Microservices & Low-Level Agents

Commercial Impact & ROI

Demonstrates enterprise-scale distributed systems orchestration, real-time threat telemetry, and multi-language microservices architecture.

Technical Architecture

Distributed security fleet orchestrated on Kubernetes with Skaffold. High-performance native sentinel agents implemented in Rust and C++ for sub-millisecond host inspection, streaming telemetry to Python ML analytics and a real-time reactive dashboard.

Orchestration
K8s / Skaffold
Native Agents
Rust & C++
Telemetry
Streaming ML
Architecture
Microservices
Kubernetes Rust C++ Python ML Skaffold Docker Microservices
systems_core
read_only
// Low-overhead C++ sentinel agent packet hook
void SentinelEngine::ProcessNetworkFrame(const PacketDescriptor& packet) {
    if (__builtin_expect(packet.payload_size > MTU_THRESHOLD, 0)) {
        AlertAnomaly(AnomalyType::MALFORMED_HEADER, packet.source_ip);
    }
}
Verified Architecture 100% Deterministic
Fintech Microservice #06

EndptSec Billing & Licensing Engine

Universal Multi-Tenant Licensing Microservice

Commercial Impact & ROI

Eliminates duplicate billing implementations across product portfolios, centralizing Stripe and Lemon Squeezy webhook ingestion into one resilient hub.

Technical Architecture

High-concurrency Node.js/TypeScript microservice minting cryptographically random 256-bit license keys. Automatically routes validation by key prefix (ews_, eg_, mle_) and handles multi-gateway webhook reconciliation with zero data loss.

Gateways
Stripe / Lemon
Key Strength
256-Bit Crypto
Routing
Prefix Directed
Deploy
Docker / Caddy
TypeScript Stripe API Lemon Squeezy Webhooks Caddy Docker REST API
systems_core
read_only
// Prefix-directed license routing
export async function verifyLicenseKey(key: string): Promise<EntitlementResult> {
  const [prefix] = key.split("_");
  const project = PROJECT_REGISTRY[prefix];
  if (!project) throw new InvalidPrefixError(prefix);
  return await project.validateEntitlements(key);
}
Verified Architecture 100% Deterministic
Client & Desktop #07

Native Desktop & Web Applications

Synapse Browser & Arabic Mastery

Commercial Impact & ROI

Proves end-to-end product delivery capability across native cross-platform desktop shells (Tauri/Rust) and responsive interactive web apps.

Technical Architecture

Synapse Browser utilizes Tauri (Rust native window manager & IPC bridge) with React/TypeScript frontend. Arabic Mastery delivers a responsive educational platform with interactive curriculum modules and state persistence.

Desktop Shell
Tauri (Rust)
UI Engines
React / Vite
Platform
Win / Mac / Web
Design
Tailwind CSS
Tauri Rust React TypeScript Vite Tailwind CSS
systems_core
read_only
// Tauri Rust IPC handler for secure native desktop bridging
#[tauri::command]
async fn execute_sandboxed_command(cmd: String) -> Result<String, String> {
    // Isolated process execution with platform security guarantees
    run_secure_pipeline(&cmd).await.map_err(|e| e.to_string())
}
Verified Architecture 100% Deterministic
Core Principles

Architectural Philosophy

The engineering rules that govern every line of code deployed across my fleet.

01

Zero Runtime Bloat

Eliminate unnecessary client overhead and sluggish dependencies. Whether compiling to native x86_64, WebAssembly at the edge, or C++/Qt desktop interfaces, compute heavy logic close to the metal before delivering to the user.

02

Principle of Least Privilege

Every permission, scope, and token request is strictly minimized. Never request blanket database or merchant scopes when granular read/write discounts suffice.

03

Deterministic Safety

From kernel memory allocators in Buraq OS to AST PR gatekeepers, systems are engineered to fail closed, eliminate silent runtime panics, and guarantee deterministic uptime.

Direct Engagement

Ready to build high-margin, sub-millisecond systems?

Available for specialized e-commerce systems consulting, custom Shopify Function engineering (Rust/Wasm), and staff-level systems or security architecture roles.