Choosing Python or Go for Microservices: A Performance Reality Check

Building a Multimodal Agent with the ADK, Amazon Lightsail, and Gemini Flash Live 3.1: Leveraging the Google Agent Development Kit (ADK) and the underlying Gemini LLM to build Agentic apps using the Gemini Live API with the Python programming language deployed to Amazon Lightsail. Aren’t There a Billion Python ADK Demos? Yes there are. Python has traditionally been the main coding language for ML and AI tools. The goal of this article is to provide a minimal viable basic working ADK streaming multi-modal agent using the latest Gemini Live Models. In the Spirit of Mr. McConaughey’s “alright, alright, alright” So what is different about this lab compared to all the others out there? This is one of the first implementations of the latest Gemini 3.1 Flash Live Model with the Agent Development Kit (ADK). The starting point for the demo was an existing Code lab- which was updated and re-engineered with Gemini CLI. The original Codelab- is here: Way Back Home - Building an ADK Bi-Directional Streaming Agent | Google Codelabs What Is Python? Python is an interpreted language that allows for rapid development and testing and has deep libraries for working with ML and AI: Welcome to Python.org Python Version Management One of the downsides of the wide deployment of Python has been managing the language versions across platforms and maintaining a supported version. The pyenv tool enables deploying consistent versions of Python: GitHub - pyenv/pyenv: Simple Python version management As of writing — the mainstream python version is 3.13. To validate your current Python:python --version Python 3.13.12 Amazon Lightsail Amazon Lightsail is an easy-to-use virtual private server (VPS) provider and cloud platform designed by AWS for simpler workloads, offering developers pre-configured compute, storage, and networking for a low, predictable monthly price. It is ideal for hosting small websites, simple web apps, or creating development environments. More information is available on the official site here: Amazon's Simple Cloud Server | Amazon Lightsail And this is the direct URL to the console:https://lnkd.in/eV7DaV8y Gemini Live Models Gemini Live is a conversational AI feature from Google that enables free-flowing, real-time voice, video, and screen-sharing interactions, allowing you to brainstorm, learn, or problem-solve through natural dialogue. Powered by the Gemini 3.1 Flash Live model, it provides low-latency, human-like, and emotionally aware speech in over 200 countries. More details are available here: Gemini 3.1 Flash Live Preview | Gemini API | Google AI for Developers The Gemini Live Models bring unique real-time capabilities than can be used directly from an Agent. A summary of the model is also available here:https://lnkd.in/ekCsUE3q Gemini CLI If not pre-installed… #genai #shared #ai

Multi-Agent A2A with the Agent Development Kit(ADK), AWS Lightsail, and Gemini CLI: Leveraging the Google Agent Development Kit (ADK) and the underlying Gemini LLM to build Multi-Agent Applications with A2A protocol support using the Python programming language. Aren’t There a Billion Python ADK Demos? Yes there are. Python has traditionally been the main coding language for ML and AI tools. The goal of this article is to provide a multi-agent test bed for building, debugging, and deploying multi-agent applications. What you talkin ‘bout Willis? So what is different about this lab compared to all the others out there? This is one of the first deep dives into a Multi-Agent application leveraging the advanced tooling of Gemini CLI. The starting point for the demo was an existing Codelab- which was updated and re-engineered with Gemini CLI. The original Codelab- is here: Building a Multi-Agent System | Google Codelabs What Is Python? Python is an interpreted language that allows for rapid development and testing and has deep libraries for working with ML and AI: Welcome to Python.org Python Version Management One of the downsides of the wide deployment of Python has been managing the language versions across platforms and maintaining a supported version. The pyenv tool enables deploying consistent versions of Python: GitHub - pyenv/pyenv: Simple Python version management As of writing — the mainstream python version is 3.13. To validate your current Python:python --version Python 3.13.13 Amazon Lightsail Amazon Lightsail is an easy-to-use virtual private server (VPS) provider and cloud platform designed by AWS for simpler workloads, offering developers pre-configured compute, storage, and networking for a low, predictable monthly price. It is ideal for hosting small websites, simple web apps, or creating development environments. More information is available on the official site here: Amazon's Simple Cloud Server | Amazon Lightsail And this is the direct URL to the console:https://lnkd.in/eV7DaV8y The Lightsail console will look similar to: Gemini CLI If not pre-installed you can download the Gemini CLI to interact with the source files and provide real-time assistance:npm install -g @google/gemini-cli Testing the Gemini CLI Environment Once you have all the tools and the correct Node.js version in place- you can test the startup of Gemini CLI. You will need to authenticate with a Key or your Google Account:▝▜▄ Gemini CLI v0.33.1 ▝▜▄ ▗▟▀ Logged in with Google /auth ▝▀ Gemini Code Assist Standard /upgrade no sandbox (see /docs) /model Auto (Gemini 3) | 239.8 MB Node Version Management Gemini CLI needs a consistent, up to date version of Node. The nvm command can be used to get a standard Node environment: GitHub - nvm-sh/nvm: Node Version Manager - POSIX-compliant bash script to manage multiple… #genai #shared #ai

I stood on the big stage at PyCon DE & PyData 2026 last week and told 2,000 Python engineers something nobody wanted to say out loud. "AI can do everything except?" The room went quiet. Then the heads started nodding. That was my lightning talk, and it set the tone to end the day full of honest, grounded engineering conversations. Summary of other talks and tutorials I attended on Day 2 - Ship Data with Confidence: Declarative Validation for PySpark & Pandas. Ryan Sequeira's talk on declarative validation for PySpark & Pandas hit on something most teams get backwards. We build monitoring to catch bad data after it breaks things, when we should be blocking it from entering the pipeline in the first place. His open-source approach embeds validation directly into the pipeline, so errors surface at the earliest possible stage. Reactive is expensive. Proactive is a design choice. - "From Struggling to Mastery: A Practical Guide to Data Pipeline Operations" Akif Cakir introduced an Operational Excellence Maturity Pyramid a 5-level framework (Struggling → Basic → Decent → Strong → Mastery) for data teams trying to grow without falling apart. The uncomfortable truth he put on the slide: most teams know they need to improve, but they have no shared definition of what "better" even looks like. You can't measure progress without a map. - "Building Secure Environments for CLI Code Agents" Harald Nezbeda made a practical case for containerizing CLI code agents in full isolation from your host system persistent auth, workspace access via volume mounts, full API logging, all sandboxed. As AI agents get more capable, this kind of thinking moves from "nice to have" to "why didn't we do this sooner." - "Accelerate FastAPI Development with OpenAPI Generator". Evelyne G. & Kateryna Budzyak's tutorial on OpenAPI Generator was a 90-minute deep dive into a workflow I wish I'd known earlier. Design your API as an OpenAPI spec in YAML, and the generator spits out your FastAPI endpoints and strictly-typed Pydantic models automatically no GenAI, just clean contract-first engineering. Less ambiguity between teams. Less debugging. More trust. - "Build a web coding platform with Python, run in WebAssembly" -  Maris Nieuwenhuis built an interactive Python coding platform using Pyodide + WebAssembly that executes code entirely client-side. No backend. No security risks from running user code on a server. No infrastructure overhead. Just Python, in the browser, actually working. The crowd reaction said everything. - Django-Q2: Async Tasks Made Simple" Moin Uddin introduced Django-Q2. It is the alternative nobody told you about. Moin Uddin made a compelling case for Django-Q2 async tasks and cron jobs using your existing database as a broker, no Redis, no RabbitMQ, no 3-page config file. For small to medium projects that need to move fast, this might be the most practical thing I heard all day. 6 sessions. One lightning talk I'll remember for a while.

📨 AI-Driven Micro-Loan Platform 5/10: The gRPC Fast-Lane – When "Async" isn't fast enough ⚡ In Post 3, we talked about the "Deep-Dive" via Service Bus. But what if you need an answer now? For the initial "Pre-Score" (the 5-second decision that keeps a user in the app), we can't wait for a message queue. We need a direct, high-speed connection between .NET 10 and Python. Enter gRPC. 🏎️ 1. Why gRPC over REST? ⚖️ Most teams default to JSON over HTTP. In a high-volume microservices environment, that's "death by a thousand cuts." Protobuf vs. JSON: gRPC uses Protocol Buffers (binary). It’s smaller, faster to serialize, and strictly typed. Multiplexing: Using HTTP/2, we keep a single connection open for multiple requests, reducing the overhead of constant "handshakes." 2. The "Pre-Score" Flow 🟢 When the user hits "Check My Limit": .NET API calls the Python ML Service via a gRPC client. Python pulls the "Lightweight" features from Redis. Inference happens in <20ms. The result returns to .NET, and the user sees a "Preliminary Offer" immediately. 3. The Contract-First Advantage 📝 One of the biggest headaches in Polyglot teams (.NET + Python) is API breaking changes. The .proto file: This is our "Single Source of Truth." Both teams agree on the input and output types. Auto-Generation: .NET generates its client, and Python generates its server from the same file. No more "Expected an integer but got a string" bugs in production. 4. Handling the "Timeout" Trap 🛡️ Direct calls are risky. If Python is slow, .NET hangs. The Strategy: We implement strict Deadlines. If Python doesn't answer in 100ms, the gRPC call cuts off. The Fallback: If the Fast-Lane fails, the system gracefully falls back to the "Deep-Dive" Async flow we discussed earlier. The user gets a "We're processing your request" message instead of a crash. 📈 The Results: ✅ Real-Time UX: Users get instant gratification. ✅ Polyglot Harmony: .NET and Python talk as if they were in the same project. ✅ Efficiency: Reduced CPU overhead on both sides compared to REST/JSON. 🧠 Post 6: The Watchtower – Real-time Observability with OpenTelemetry & Dashboards. #gRPC #Microservices #DotNet #Python #SystemDesign #FinTech #MLOps #API #SoftwareEngineering #PerformanceOptimization

There’s a small change coming to Python that looks simple on the surface — but has real impact once you think in terms of systems. PEP 810 introduces explicit lazy imports - modules don’t load at startup - they load only when actually used At first glance, this sounds like a minor optimization. It’s not. Every engineer has seen this pattern: You run a CLI with -help - and it still takes seconds to respond Why? Because the runtime eagerly loads everything - even code paths you’ll never touch in that execution That startup cost adds up - especially in services, scripts, and short-lived jobs Lazy imports change that behavior. Instead of front-loading everything at startup - the runtime defers work until it’s actually needed So now: - unused dependencies don’t slow you down - cold starts improve - CLI tools feel instant again It’s a small shift in syntax - but a meaningful shift in execution model What’s interesting is not the idea itself. Lazy loading has existed for years - across languages, frameworks, and runtimes But Python never had a standard way to do it - teams built custom wrappers - some even forked the runtime That fragmentation was the real problem. PEP 810 fixes that - by making it opt-in - preserving backward compatibility - while finally standardizing the pattern That decision matters more than the feature. Earlier attempts tried to make lazy imports the default - and ran straight into compatibility risks This time, the approach is pragmatic: - no breaking changes - no surprises in existing systems - but a clear path for teams that need performance gains That’s how ecosystem-level changes actually stick. From a systems perspective, this connects to a broader principle: Startup time is part of user experience. Whether it’s: - a CLI tool - a containerized service - a serverless function Cold start latency directly impacts usability and cost And most of that latency isn’t business logic - it’s initialization overhead Lazy imports attack that overhead at the root. Not by optimizing logic - but by avoiding unnecessary work entirely Which is often the highest-leverage optimization you can make. The bigger takeaway isn’t just about Python. It’s this: Modern systems are moving toward just-in-time execution - load less upfront - execute only what’s needed - keep everything else deferred You see it in: - class loading strategies - dependency injection frameworks - container startup tuning Now it’s becoming part of the language itself. It’ll take time before this shows up in everyday workflows. But once it does, expect a shift in how people structure imports - especially in performance-sensitive paths Explore more : https://lnkd.in/gP-SeCMD #SoftwareEngineering #Python #Java #Backend #Data #DevOps #AWS #C2C #W2 #Azure #Hiring #BackendEngineering Boston Consulting Group (BCG) Kforce Inc Motion Recruitment Huxley Randstad Digital UST CyberCoders Insight Global

7,250 downloads. 1,880 clones in 14 days. 404 developers using it . When we started building SynapseKit, we made one rule: Don't ship the framework without shipping the documentation. Because I've used too many "promising" Python libraries that had great internals and zero explanation of how to actually use them. You'd clone it, stare at the source code for 20 minutes, and give up. SynapseKit was built to be the opposite of that. What is SynapseKit? An async-native Python framework for building LLM applications — RAG pipelines, AI agents, and graph workflows — across 27 providers with one interface. Swap OpenAI for Anthropic[Anthropic]. Swap Anthropic for Ollama[Ollama]. Zero rewrites. Streaming-first. Async by default. Two hard dependencies. But here's what actually makes me proud: The 7,250 downloads aren't from a viral post or a Product Hunt launch. They came from developers finding it on GitHub, engineers discovering it on PyPI while searching for tools, and people landing on the docs and actually understanding what they found. That last one is everything. Good documentation doesn't just explain your code. It builds trust. It tells engineers — "this project is maintained, this project respects your time, this project will still work six months from now." 105 open issues. 30 pull requests in March alone. People aren't just downloading SynapseKit — they're contributing to it. What's inside: → RAG Pipelines — streaming, BM25 reranking, memory, token tracing → Agents — ReAct loop, native function calling for OpenAI / Anthropic / Gemini / Mistral → Graph Workflows — DAG async, parallel routing, human-in-the-loop → Observability — CostTracker, BudgetGuard, OpenTelemetry — no SaaS required → Vector Stores — ChromaDB, FAISS, Qdrant, Pinecone behind one interface All of it documented. All of it referenced. All of it open source. If you're building LLM applications in Python, I'd genuinely love for you to take it for a spin. 📖 https://lnkd.in/dvr6Nyhx ⭐ https://lnkd.in/d2fGSPkX And if you find something broken, missing, or confusing - open an issue. That's exactly how 105 conversations started. No framework survives bad documentation. We're building both. #Python #OpenSource #LLMFramework #SynapseKit #AIEngineering #RAG #AIAgents #BuildInPublic #MachineLearning #LLM

I recently expanded a Packt open-source microservices codebase (Flask + Python) and turned it into a deeper learning project around distributed systems architecture.     Here's what I built on top of the original:     → Gave each service its own isolated SQLite3 database (User, Product, Order) - no shared tables, no hidden coupling  → Extended the Order Service schema to support order items with unit price snapshots, so historical accuracy is preserved even if prices change later  → Designed schemas that can scale independently: each service owns its data contract and can swap to PostgreSQL with zero impact on the others  → Containerized all 4 services with Docker Compose, each with its own volume mount for persistence     The thing that clicked for me while doing this:     A service boundary is a change boundary.     If two things always deploy together, change together, and break together, they're not two services. They're one service pretending to be two, with extra network hops and failure points in between.     I also learned why bad decomposition is worse than a monolith. Splitting by technical layer (DatabaseService / APIService / LogicService) adds distributed complexity with zero business value. The right split is always along business capabilities - what the business actually does, not how the code is organized.     Concepts I got hands-on with:  - Database per Service pattern  - Service-Oriented Architecture (SOA)  - Synchronous (REST) vs asynchronous (event-driven) service communication  - Bounded contexts from Domain-Driven Design  - Independent deployment pipelines per service     If you're getting started with microservices, this pattern reference from Chris Richardson is the best mental model I've found: https://lnkd.in/gKcyNcEj     Original repo from PacktPublishing: https://lnkd.in/gENvsSej  The version I worked on: https://lnkd.in/gf_HxcyX     Building this from scratch (well, expanding it from scratch) made distributed systems a lot less abstract. Highly recommend it as a learning project if you're coming from a Flask/FastAPI background.     #Microservices #Python #Flask #Docker #DistributedSystems #SystemDesign #BackendDevelopment #SoftwareEngineering #LearningInPublic

Scaling Python backends with asyncio and PostgreSQL (asyncpg) requires thinking beyond async/await syntax. If you don't map your coroutines to the underlying OS-level sockets and memory buffers, you will hit silent deadlocks, connection exhaustion, and OOM crashes. Spent a lot of time reading and building lately, and I wanted to share the most important aspects of building high-performance async database drivers. Here’s what I’ve learned: Throttle with asyncio.BoundedSemaphore: Don't just dump 10,000 tasks onto the event loop. Match your semaphore limit to your connection pool's max_size. This provides backpressure, preventing task queue timeouts and event loop thrashing. (Tip: Always use BoundedSemaphore over Semaphore to catch rogue .release() calls). Pipeline with executemany(): Stop running .execute() in a loop. executemany leverages the Postgres extended query protocol (PARSE once, BIND/EXECUTE many) to pack the TCP window and eliminate thousands of network Round Trip Times (RTT). Isolate State with Savepoints: Use nested async with conn.transaction() blocks to handle partial payload failures. When an inner block fails, it just flags the Postgres SubXID as aborted (leaving dead tuples for the VACUUM process) while allowing the parent transaction to safely commit. Prevent OOMs with Server-Side Cursors: Never use .fetch() for massive multi-million row exports. Stream them via async for row in conn.cursor(query, prefetch=chunk_size). This guarantees your Python process memory stays strictly bounded to the chunk size, no matter how large the table gets. Shield Your Cleanup: If a client abruptly drops an HTTP connection, the ASGI server will inject an asyncio.CancelledError. If you don't wrap your pool.release() and tx.rollback() in asyncio.shield() inside your Unit of Work, the network socket will be left permanently checked out, leading to a silent pool deadlock. Adopt asyncio.TaskGroup: (Python 3.11+) Move away from naked asyncio.gather(). TaskGroups provide structured concurrency—if one concurrent validation query fails, the siblings are safely and instantly cancelled, returning their leased connections to the pool immediately. Avoid Distributed Transactions: Don't attempt Two-Phase Commits (2PC) across microservices using the event loop; it destroys throughput. Rely on the Transactional Outbox pattern: commit your local database mutation and an event payload in the same transaction, and let your message broker manage eventual consistency. Stop treating the event loop like magic. Treat it like an I/O multiplexing coordinator. #Python #Asyncio #PostgreSQL #BackendEngineering #SoftwareArchitecture #DistributedSystems

Understanding Asyncio Internals: How Python Manages State Without Threads A question I keep hearing from devs new to async Python: “When an async function hits await, how does it pick up right where it left off later  with all its variables intact?” Let’s pop the hood. No fluff, just how it actually works. The short answer: An async function in Python isn’t really a function – it’s a stateful coroutine object. When you await, you don’t lose anything. You just pause, stash your state, and hand control back to the event loop. What gets saved under the hood? Each coroutine keeps: 1. Local variables (like x, y, data) 2. Current instruction pointer (where you stopped) 3. Its call stack (frame object) 4. The future or task it’s waiting on This is managed via a frame object, the same mechanism as generators, but turbocharged for async. Let’s walk through a real example async def fetch_data():     await asyncio.sleep(1)   # simulate I/O     return 42 async def compute():     a = 10     b = await fetch_data()     return a + b Step‑by‑step runtime: 1. compute() starts, a = 10 2. Hits await fetch_data() 3. Coroutine captures its state (a=10, instruction pointer) 4. Control goes back to the event loop 5. The event loop runs other tasks while I/O happens 6. When fetch_data() completes, its future resolves 7. compute() resumes from the exact same line b gets the result (42) 8. Returns 52 No threads. No magic. Just a resumable state machine. Execution flow: Imagine a simple loop: pause → other work → resume on completion.) Components you should know: Coroutine: holds your paused state Task: wraps a coroutine for scheduling Future: represents a result that isn’t ready yet Event loop: the traffic cop that decides who runs next Why this matters for real systems This design is why you can build high‑concurrency APIs, microservices, or data pipelines without thread overhead. Frameworks like FastAPI, aiohttp, and async DB drivers rely on this every single day. Real‑world benefit: One event loop can handle thousands of idle connections while barely touching the CPU. A common mix‑up “Async means parallel execution.” Not quite. Asyncio gives you concurrency (many tasks making progress), not parallelism (multiple things at the exact same time). It’s cooperative, single‑threaded, and preemption‑free. Take it with you Python async functions = resumable state machines. Every await is a checkpoint. You pause, but you never lose the plot. #AsyncIO #PythonInternals #EventLoop #Concurrency #BackendEngineering #SystemDesign #NonBlockingIO #Coroutines #HighPerformance #ScalableSystems #FastAPI #Aiohttp #SoftwareArchitecture #TechDeepDive

Most tutorials about async Python show you how to use asyncio. Almost none of them show you how to decide what should be async in the first place. I've been working on a backend pipeline that processes data-driven workflows — intake, classify, transform, store. When I inherited it, the whole thing was synchronous. Every API call, every database write, every LLM classification step waited in line. The throughput was fine for small volumes. At scale, it was a bottleneck hiding in plain sight. The temptation was to slap async on everything. That would have been a mistake. Here's the decision framework I actually used. Map the dependency graph first. Draw every operation and draw arrows between the ones that depend on each other's output. The operations with no arrows between them are your parallelization candidates. Everything else stays sequential. This sounds obvious but I've seen entire teams skip it and end up with race conditions they spend weeks debugging. I/O-bound waits are the real wins. An LLM API call that takes 800ms while your CPU does nothing — that's the perfect async candidate. A CPU-heavy data transformation that takes 200ms — making that async buys you almost nothing and adds complexity. I was ruthless about only converting the I/O operations: external API calls, database queries, file reads. The compute stayed synchronous. Batch where the API allows it. Some of the biggest gains didn't come from async at all. They came from batching — sending ten classification requests in one call instead of ten sequential calls. Batching and async together is where the real throughput jumps live, but batching alone often gets you 80% of the way there. Add backpressure before you add speed. The first time I parallelized the pipeline without a semaphore, it worked beautifully for thirty seconds and then overwhelmed the downstream API with concurrent requests. Rate limiting, semaphores, and bounded queues aren't optional — they're the difference between a fast system and one that takes itself down. The result was a 20% throughput improvement. Not by rewriting the system. By identifying the six operations that were waiting unnecessarily and letting them run concurrently while everything else stayed exactly the same. Async isn't a feature you add to a codebase. It's a scalpel you apply to the specific places where waiting is the bottleneck. #Python #AsyncIO #Backend #SoftwareEngineering #AIEngineering #SystemDesign #BuildInPublic #AppliedAI