Hardening SSH without locking the user out
The problem StackSentry's auto-fix applies PermitRootLogin prohibit-password to stop password brute-force on root. But if the user is currently authenticating with a password, applying it locks them out of their own server permanently — the next SSH session simply fails.
The tension The correct security control is also a foot-gun. Most auto-fix tools apply it blindly. Refusing to automate it at all would defeat the purpose. The fix had to happen automatically and be impossible to get locked out by.
The decision - Rejected — apply it directly: fast, but strands the user outside their own box.
- Rejected — make the user generate and install a key manually first: safe, but that is the tedious work the tool exists to remove.
- Chosen — a four-step preflight: generate an Ed25519 key locally, install the public key over the existing password session, open a fresh connection using only the new key to prove it works, and only then disable password login. If the key-only test fails, sshd_config is never touched.
The outcome The destructive change is gated behind a verification that runs before it, not after. The user cannot be locked out, because password auth is only disabled once key auth is proven to work on a separate connection. Already-key-based users skip the preflight entirely.
0 lock-outs by design
A weekly email that never sent — because nothing scheduled it
The problem The admin platform had a 'weekly digest' preference the user could toggle on. It saved correctly, but the email never arrived. The feature looked complete — a real toggle, wired to a real preference — but on the timing side it was connected to nothing.
The tension The obvious assumption was a bug in the email code. But the email code worked fine for per-event alerts. The real question was what was supposed to trigger it weekly — and investigation showed no scheduler existed at all: no Celery Beat, no relevant cron job. The Celery worker used celery multi, which cannot embed beat.
The decision - Rejected — a cron job calling a script: works, but lives outside the existing Celery world and duplicates plumbing.
- Chosen — a dedicated Celery Beat service: since the email tasks were already Celery tasks, Beat is the idiomatic home. Added a separate systemd service (beat schedules, the existing worker runs), plus a manual-trigger endpoint so the digest could be tested immediately instead of waiting a week to confirm it worked.
The outcome The root cause was not the email code but a missing scheduler entirely — a 'feature' that had never once run. Fixing it added reusable scheduled-task infrastructure the platform lacked, and the manual trigger meant the fix was verifiable in seconds rather than trusted blindly until the next Monday.
Fake-complete feature → actually scheduled
An ML pipeline blocked by the CPU underneath it
The problem Contourify's object detection runs on YOLOv8, which depends on NumPy and PyTorch. On the target VPS, those libraries refused to run at all — the host CPU lacked AVX instruction support, which modern NumPy/PyTorch wheels assume is present.
The tension This was not a code bug that could be patched in the application. It was the silicon underneath the whole stack. No amount of application-level work fixes a missing CPU instruction set — the pipeline that was the entire point of the project could not execute on the chosen host.
The decision - Diagnosed the failure down to the AVX requirement rather than treating it as a dependency or version issue — the crash surfaced as a low-level illegal instruction, not a clean import error.
- [FILL IN: the actual path you took — e.g. installed CPU-only / no-AVX builds of the libraries, moved detection to a different host or service, switched runtime, or another route. State what you actually did.]
The outcome [FILL IN: the real result — e.g. 'the pipeline ran on <X>, the subdomain went live at photocontour.vickkykruzprogramming.dev.' Keep it factual.]
Root cause: hardware, not code
Auto-neutralising an attack without breaking the network
The problem Vigilo detects ARP spoofing on shared Wi-Fi and neutralises the attacker automatically — before credentials can be stolen — for business owners with no technical knowledge. Auto-responding to a live attack is risky: act wrongly and you disrupt legitimate traffic on the same network.
The tension [FILL IN: the real trade-off you faced. Likely candidates: how to be confident a detected ARP change is genuinely malicious vs a normal network event before auto-responding (false-positive risk), and how to surface a network-layer attack to a non-technical owner in language they can act on. State the actual tension you designed around.]
The decision - [FILL IN: what you actually did to decide an ARP change is an attack — e.g. signature/threshold logic, gateway MAC verification, etc.]
- [FILL IN: how the automatic response works and why you chose that mechanism.]
The outcome [FILL IN: the real result — what the tool reliably catches, and how the plain-English alerting works in practice.]
[FILL IN: e.g. 'Attack cut off automatically, owner alerted in plain English']
[FILL IN: the real engineering decision behind Joam Collections]
The problem [FILL IN: the genuine problem you hit on this e-commerce build — infrastructure reliability, a deployment/security decision, separating the storefront from the API, handling real transaction volume, or similar. If there is no headline decision story here, it is honestly fine to remove this study rather than pad it.]
The tension [FILL IN: why the obvious approach was not right.]
The decision - [FILL IN: the option you rejected and why.]
- [FILL IN: the option you chose and why.]
The outcome [FILL IN: what it achieved.]
[FILL IN: a short factual result]