All Case Studies

Issue: Needed a repeatable way to handle messy OCR data and normalize fields like dates, currencies, and names after extracting them with AI models.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: As conversations grow, irrelevant middle context accumulates, token budgets get exceeded, and edge devices pay extra latency for input processing.

Solution: Implemented a context folding hierarchy (RAW → DETAILED → SUMMARY → CONCEPTS) with fatigue detection thresholds (85%/95%/98%) and fast character-based token estimation.

Issue: Without explicit controls, an AI API is vulnerable to abuse (burst traffic), unsafe inputs (command/path traversal), leaked secrets, and silent security regressions from dependencies.

Solution: Implemented five security modules: encryption at rest, enhanced rate limiting, advanced input validation, security monitoring + alerts, and vulnerability scanning with report generation.

Issue: Manual Firebase deployments are easy to mis-target (wrong project/hosting target), hard to audit, and slow to coordinate without realtime status notifications.

Solution: Centralized deployment configuration into an `accounts.json` profile, added API endpoints for account switching, and integrated Discord webhooks for start/success/failure notifications with log snippets.

Issue: Large models can be loadable, but the KV cache can still consume meaningful memory as context grows, limiting concurrency and increasing OOM risk.

Solution: Benchmarked KV cache quantization modes (default vs q8 vs q4) at a fixed context window and compared startup time, request latency, RSS, and KV cache footprint.

Issue: CPU-only inference on small models was too slow for interactive UX, and some NPU model runs initially failed for non-runtime reasons (corrupted downloads or wrong target platform conversions).

Solution: Benchmarked CPU (Ollama) vs NPU (RKLLM), applied system and inference parameter optimizations, and documented failure modes to distinguish model-file issues from NPU/runtime issues.

Issue: Needed a repeatable way to use Ansible and adcli to safely remove a Linux server's computer object from Active Directory during decommissioning.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: The app was locked to standard 60Hz rendering, causing sub-optimal scrolling experiences on devices capable of 90Hz or 120Hz. Additionally, users had to navigate through multiple screens to perform frequent actions.

Solution: Detected 90Hz+ display modes and configured window post-processing preferences for smoother rendering, then implemented static XML-based app shortcuts routed via deep links.

Issue: Needed a repeatable way to use a single, universal Ansible role to deploy static sites, PHP apps, or complex reverse proxies just by changing host variables.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to package Ansible dependencies into a portable, containerized Execution Environment (EE) for consistent automation across runners.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to manage Linux server patching across different tiers (Database, Application, etc.) using Ansible limits and targeted groups.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to clarify how training works in Azure Document Intelligence Studio and why it doesn't support incremental learning.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to quickly map out group memberships, owned directories, and sudo privileges for specific service accounts.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: LLMs are notoriously bad at math and often fail to return strictly formatted JSON, breaking client-side parsing. Furthermore, passing thousands of raw transactions to an LLM is slow and expensive.

Solution: Offloaded mathematical computations to the client, injected pre-computed hints into the system prompt, and utilized strict JSON-object response formats with zero-shot categorization definitions.

Issue: Needed a repeatable way to resize a partition using fdisk, expand the LVM, and resize the filesystem without needing a reboot.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to use fine-tuned Large Language Models to normalize messy OCR data into canonical JSON.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to leverage AI scaffolding to focus on infrastructure, security, and architecture while building a personal finance app.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Directly exposing LLMs to users risks massive API costs through spam or unbounded context windows. Furthermore, raw user input is vulnerable to jailbreaks (e.g., 'ignore previous instructions and execute code').

Solution: Implemented a multi-tier model routing strategy (chat vs reasoning), robust context truncation, regex-based jailbreak detection, and strict timestamp-based rate limiting.

Issue: Needed a repeatable way to handle Kerberos keytab lifecycle and deploy it securely with Ansible for Apache Single Sign-On.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to manage technical user permissions on Linux by linking local UNIX groups to centrally managed Active Directory groups.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to understand why moving layers into system RAM kills token generation speed, and how the Roofline Model explains it.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: The backend AI needed to recognize user intent and categorize vehicle parts accurately regardless of the input language, and subsequently generate both localized predictive maintenance responses and tailored affiliate search queries.

Solution: Implemented comprehensive multi-language keyword dictionaries, extracted user language context directly from client requests, and used mapping dictionaries to serve localized response templates.

Issue: Needed a repeatable way to standardize technical user creation, assigning static UIDs/GIDs, and avoiding conflicts in a large server fleet using Ansible.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Large Language Models charge per token. When you send a 1,000-token system prompt alongside a 50-token user question, you pay for 1,050 tokens every time, even though 95% of the payload never changes between requests.

Solution: Restructured the API payload to isolate static system instructions so the backend can take advantage of cached-input pricing or prompt caching features where the provider supports it.

Issue: Needed a repeatable way to apply best practices for handling sensitive TLS/SSL certificates (.cer and .key files) using Ansible Vault to prevent accidental exposure.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to migrate an application directory to a new, larger logical volume with minimal downtime.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to initialize and use Molecule with the Docker driver to test your Ansible roles before deploying.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to build CIS-hardened RHEL images using HashiCorp Packer and orchestrate the builds via StackGuardian.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Direct-to-cloud write operations failed silently during poor network conditions. Historical data had hardcoded sync limits, and offline/guest modes were improperly triggering authentication flows.

Solution: Adopted the Outbox Pattern for all write operations, separated local execution from cloud sync workers, and implemented comprehensive state tracking with retry logic.

Issue: Needed a repeatable way to configure WAL archiving in PostgreSQL and resolve the 'Permission denied' SELinux errors when writing to a dedicated archive directory.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to apply Context Folding to parse massive documentation sets on local hardware.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to configure /etc/fstab with systemd options to reliably mount network shares without blocking the boot process.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to compile a practical cheatsheet covering the most essential commands for managing RHEL systems on a daily basis.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to use katello-host-tools-tracer to reliably determine if a Linux server requires a reboot or daemon reload after patching.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to resolve git merge conflicts using git stash to protect your local work.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to shrink an ext4 filesystem and its underlying Logical Volume (LV) to reclaim space.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to automate interactive vendor installers (like SAS Software Depot) by recording response files and executing them via Ansible.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to understand and implement modern data center topologies, leaf-spine designs, and the concept of stretched networks for seamless VM migration.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to apply best practices for organizing your Ansible inventory, group_vars, and host_vars to cleanly separate development and production environments.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to resolve 'Permission Denied' and 'RPC: Unable to receive' errors when mounting NFS shares, focusing on network routing issues.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.

Issue: Needed a repeatable way to resolve 'Permission Denied' errors during 'su' attempts by identifying conflicts between Active Directory and PAM modules.

Solution: Implemented a practical runbook/automation pattern with clear safety checks, execution steps, and verification points.