of (AI Architect | ex-AWS, Lululemon, Nike) and author of Clean Architecture with Python (Packt, 2025)—joins The Deep Engineering Podcast to unpack what “clean architecture” means in a dynamic, Python-first world. We dig into how to adapt DDD and SOLID to real Python codebases, enforce the dependency rule so frameworks stay at the edge, and model entities/value objects with dataclasses and Pydantic without turning Python into Java. Sam also shares hard-won lessons from refactoring legacy systems and how to use generative AI to accelerate development while preserving architectural intent.

What you’ll learn

• How to explain and apply clean architecture in Pythonic terms—layers, boundaries, and ADRs without over-engineering

• Practical ways to enforce the dependency rule in Python using directory layout, import discipline, and fitness-function tests

• Modeling entities and value objects with dataclasses, when it’s acceptable to let Pydantic into the domain, and how to document that compromise

• Building a real test pyramid: fast, pure domain unit tests; integration tests across layers; and focused end-to-end coverage

• Incremental strategies for refactoring legacy Python systems (strangler-fig, bounded contexts, gateways) instead of Big Bang rewrites

• How AI coding tools and LLM-based services fit into clean architecture—as outer-layer drivers guided by clear domain boundaries

Who should listen: Python tech leads, staff/principal engineers, backend and platform teams, software architects, and anyone responsible for keeping growing Python systems maintainable while introducing AI and new frameworks safely.

AI is already in the loop for writing code, reviewing changes, and even sketching architecture diagrams—but turning those capabilities into resilient, auditable, production-grade systems in regulated domains is a different problem. In payments and financial services especially, architects have to reconcile non-deterministic models with deterministic guarantees around correctness, security, compliance, and cost.

In this conversation, we speak with Amar Akshat—SVP of Architecture at Paysafe Group and author of the forthcoming Decode the Compiler (Packt, 2026). At Paysafe, Amar has led large-scale modernization and AI-native transformation across payments, wallets, and compliance platforms; earlier at Apple, he helped shape the architectural foundations of Apple Pay and contributed to wallet and tokenization frameworks. His current work focuses on making architecture itself intelligent—through agentic systems like MCPX and ArchX, “cell” architectures that keep decision paths safely bounded, and treating prompts, guardrails, and evals as first-class architectural assets.

Over the course of the interview, Amar explains when to keep workflows purely deterministic versus putting an AI in the path, how to structure data planes, guardrails, and system prompts as design primitives, and how to choose between modular monoliths and microservices for AI-heavy workloads. He shares concrete practices around confidence-based routing and trust deltas, prompts-as-code and AI Behavior Reviews, prompt manifests as “Dockerfiles for AI,” cost control with “cache, batch, distill,” and vendor-neutral orchestration via protocols like chat completions and MCP. We close with how compiler-level thinking—and understanding what actually happens to our code—can sharpen the way we design AI-driven systems at scale.

What you’ll learn

• How to think about agentic architecture: MCPX, ArchX, and systems that can reason about their own ADRs, diagrams, and deployments

• A practical lens for “AI in the loop vs. deterministic only” based on pattern recognition vs. regulatory and financial certainty

• How to design “cells” for wallets, payments, and ledgers so that critical analysis never leaves safe boundaries

• Ways to model data, guardrails, and system prompt packages as first-class architecture: data planes, prompt manifests, and governance

• Confidence-based routing, trust deltas, and treating prompts as code with CI/CD, eval pipelines, and AI Behavior Reviews

• Patterns for privacy and governance in regulated environments: middleware, hybrid RAG, SAML-aware access, and auditable “architectural replays”

• Strategies for cost and vendor control: “cache, batch, distill,” multi-provider orchestration with chat-completions APIs and MCP, and AI gateways

Who should listen:
Enterprise and platform architects, AI and payments leaders, SRE and ops teams responsible for AI reliability, security and compliance owners in regulated environments, and senior engineers designing AI-heavy workflows who want systems that are intelligent and explainable.

Prefer reading? You can find the complete Q&A article here:

For distilled insight read Deep Engineering #27:

To receive newsletter issues featuring interviews like this subscribe to Deep Engineering.

Subscribe now

Ayodeji Ayodele—Senior Customer Success Architect at GitHub and author of GitHub Foundations Certification Guide (Packt, 2025)—joins The Deep Engineering Podcast to share how teams can move from “using Git” to leading with GitHub. We dive into inner source as a cultural shift, practical CI/CD patterns that avoid pipeline bloat, and the security basics every org should enforce: branch protections, rule sets, secret scanning, Dependabot, and build provenance. Ayodeji also demystifies GitHub Copilot and emerging agentic workflows—how to boost throughput responsibly while keeping humans in the loop.

What you’ll learn

• Concrete habits for async collaboration: issues, PR conventions, Projects, and docs-first practices

• Choosing branching strategies (trunk vs. Git Flow) for speed and release governance

• Building quality gates into CI/CD and centralizing reusable workflows

• A pragmatic checklist for supply-chain security on GitHub

• Where AI helps (and hurts) developer productivity—and how to use Copilot responsibly

Who should listen: engineering leaders, platform/DevOps teams, security champions, and any developer aiming to level up their GitHub practice.