Granian is a fast ASGI server written in Rust that’s built to run Python web apps with less overhead and better performance.

If you’ve used Uvicorn or Gunicorn before, you can think of Granian as a step up. It feels familiar, but once you run it, you can tell it’s doing things more efficiently.

The easiest way to think about it is as a performance upgrade you can drop right into your stack. You don’t have to change your app.

You just swap the server, and your app can handle requests and concurrency in a much smoother way. It makes better use of your hardware without touching your Python code.

Welcome to Granian. Check out other 3 Random Articles here.

Imagine you’re subscribed to a newsletter called 3 Randoms. Each week, it introduces you to three lesser-known Python tools that can make your coding better. It’s like expanding your toolbox and discovering new tricks.

Subscribe now

Granian fits really well with how modern Python apps are built. Whether you’re using FastAPI, working with async code, or building APIs that need to scale, it gives you a more efficient engine underneath everything.

It handles connections cleanly, manages workers well, and helps avoid slowdowns that usually show up as your app grows.

You don’t need to rewrite anything. You don’t need to learn a new system. If you already understand ASGI, you’re already in a good spot.

In this article, I’ll walk you through a few useful things you can do with Granian that can improve how your backend runs. We’ll start a server, adjust workers for better performance, and look at how it handles async workloads.

What makes Granian stand out is that it stays focused on one thing. Running your Python app as fast and efficiently as possible. No extra layers. No complicated setup. Just solid performance with a clean developer experience.

Let’s start by installing Granian:

pip3 install granian

From there, you can spin up your server and let Granian do the work.

Thank you guys for allowing me to continue to do work that I find meaningful. This is my full time job so I hope you will support my work. You can now subscribe on the substack app!

Subscribe now

My premium readers get access to so much more, like monthly Python projects, in-depth weekly articles, this here ‘3 Randoms’ series, and my complete archive!

👉 If you get value from my work, please leave it a ❤️ and share it. This helps more people discover this newsletter, which helps me out immensely!

This Week’s Granian Tips

Read more

Python AI tools are starting to feel a lot more serious.

Not just better. Not just quicker. More organized.

We’re seeing more frameworks built with clear agent roles, better state handling, safer execution, typed outputs, and infrastructure that feels like it was built for real use, not just quick demos.

At the same time, there’s still a big push toward efficiency. More tools are helping people do more with less, whether that means cheaper hardware, smaller models, or avoiding the huge cost of retraining.

There’s a clear change happening right now.

Less, “look what this model can do.”
More, “here’s how you can actually build with it.”

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

Instead of a bunch of random one-off repos, we’re starting to see more complete systems come together.

You’ve got agent frameworks with graph-style workflows, open source tools that can run code safely in sandboxed environments, and libraries that bring type safety and validation into AI pipelines.

There are even research projects finding ways to get more performance out of existing models without having to fully retrain them.

If you’re building AI systems in Python right now, these repos aren’t just interesting to look at. They’re actually useful.

They give you a pretty clear idea of where things are going and what kinds of tools are starting to matter when you’re building real products.

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work by joining as a premium reader today.

Subscribe now

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

My Python Masterclass now includes 1:1 Live Coaching - Join Here.

👉 I genuinely hope you get value from these articles, if you do, please help me out, leave it a ❤️, and share it with others who would enjoy this. Thank you so much!

My Top 7 Repo Finds This Week

1. open-swe

Repo - Here

What it does: open-swe is an open-source asynchronous software engineering agent built on LangGraph by the LangChain team. It picks up GitHub issues labeled for automation, executes coding tasks in isolated cloud sandboxes, and pushes results back—all without human-in-the-loop intervention.

It supports multiple sandbox providers including Modal, Daytona, and Runloop.

Why it matters: For Python developers building or using AI coding automation, this is a production-ready, MIT-licensed reference architecture for end-to-end autonomous engineering workflows.

The sandbox isolation model solves a real safety and reproducibility problem that plagues DIY agent setups, and LangGraph’s stateful graph backbone makes it far easier to extend or debug than bespoke agent scripts.

Subscribe now

2. TradingAgents

Repo - Here
https://github.com/TauricResearch/TradingAgents

What it does: TradingAgents is a multi-agent LLM framework that simulates a full trading desk, with specialized agents for fundamental analysis, sentiment, news, technical analysis, research, trade execution, and risk management.

The v0.2.1 release adds support for GPT-5.4 and Gemini 3.1. Each agent role communicates structured signals to downstream agents, mimicking how real quant teams operate.

Why it matters: This framework is one of the most concrete demonstrations of multi-agent role decomposition applied to a high-stakes real-world domain.

For Python ML developers interested in finance or agent architecture, it provides a well-structured template for building LLM pipelines where different agents own different reasoning subtasks—a pattern directly transferable to other domains like healthcare or legal analysis.

👉 I genuinely hope you get value from these articles, if you do, please help me out, leave it a ❤️, and share it with others who would enjoy this. Thank you so much!

3. KittenTTS

Repo - Here
https://github.com/KittenML/KittenTTS

What it does: KittenTTS is an open-source text-to-speech library featuring ultra-lightweight models ranging from 15M to 80M parameters, optimized for CPU and edge deployment with no GPU requirement.

It ships with built-in voices, adjustable speech speed, and text preprocessing pipelines, and includes three model tiers: kitten-tts-mini, micro, and nano.

Why it matters: Most open TTS solutions demand GPU resources that are unavailable in edge, mobile, or cost-sensitive production environments—KittenTTS directly addresses that gap.

For Python developers building voice interfaces, accessibility tools, or IoT applications, having a pip-installable TTS library that runs fast on CPU dramatically lowers the deployment barrier and cost.

Subscribe now

4. llm-circuit-finder

Repo - Here
https://github.com/alainnothere/llm-circuit-finder

What it does: llm-circuit-finder is a toolkit for improving LLM reasoning by surgically duplicating specific transformer layers—a technique inspired by the RYS (Repeat Yourself) method—with no fine-tuning or retraining required.

Experiments show that duplicating layers 12–14 in Devstral-24B and layers 7–9 in Qwen2.5-32B produces meaningful gains on logical deduction benchmarks. The tool helps identify which layers are worth duplicating for a given model.

Why it matters: This is a rare example of a no-cost, no-training capability boost that any practitioner can apply to an existing model checkpoint in minutes.

For Python developers running open-weight LLMs in production, it opens a new axis of optimization—architectural surgery—that sits between prompt engineering and the much more expensive option of full fine-tuning.

👉 I genuinely hope you get value from these articles, if you do, please help me out, leave it a ❤️, and share it with others who would enjoy this. Thank you so much!

5. pydantic-ai

Repo - Here
https://github.com/pydantic/pydantic-ai

What it does: pydantic-ai is an agent framework from the Pydantic team that brings strict type safety and Pydantic validation to GenAI application development.

It is model-agnostic, supports graph-based workflows for complex multi-step reasoning, and includes built-in evaluation and testing utilities designed for production use. The project has seen 136 PRs merged in just 15 days, reflecting very active development.

Why it matters: Pydantic is already a cornerstone of the Python ecosystem, so a first-party agent framework built on those same validation idioms dramatically reduces the friction of building reliable, testable AI pipelines.

For developers who have struggled with untyped, hard-to-debug agent outputs, pydantic-ai brings the kind of structured guarantees that professional Python codebases already rely on.

Subscribe now

6. GraphZero

Repo - Here
https://github.com/KrishSingaria/graphzero

What it does: GraphZero is a zero-copy graph engine for training Graph Neural Networks on datasets exceeding 50GB without running into out-of-memory errors. It compiles graphs to disk in CSR format with feature blobs and memory-maps them as zero-copy NumPy and PyTorch tensors via a C++ and nanobind backend.

This lets GNN training proceed on consumer hardware that would otherwise be completely unable to load the dataset.

Why it matters: Large-scale GNN training has historically been gated behind expensive high-RAM server hardware, creating a significant barrier for researchers and practitioners working on graph-structured data like social networks, molecular biology, or knowledge graphs.

GraphZero’s memory-mapping approach is a practical engineering solution that could unlock this entire class of problems for developers who only have a gaming GPU or a MacBook.

👉 I genuinely hope you get value from these articles, if you do, please help me out, leave it a ❤️, and share it with others who would enjoy this. Thank you so much!

7. MiroFish

Repo - Here
https://github.com/666ghj/MiroFish

What it does: MiroFish is an AI prediction engine that uses large-scale multi-agent simulation to model complex scenarios—users upload seed materials, describe what they want to predict, and the system spins up thousands of autonomous agents in parallel digital worlds to generate detailed analytical reports.

It was built by a 20-year-old student in 10 days and raised $4.1M in crowdfunding within 24 hours.

Why it matters: Whether or not the approach is scientifically rigorous, the viral traction of MiroFish signals genuine demand for simulation-based foresight tools that go beyond simple LLM Q&A.

For Python AI developers, it is a compelling case study in how multi-agent architectures can be packaged into a compelling product narrative—and a reminder to watch the space of agent-driven simulation as it matures.

Subscribe now

Key Patterns Noted

Agents Are Getting Structured and Specialized: This week surfaced multiple frameworks for building autonomous coding and trading agents—open-swe, TradingAgents, and pydantic-ai all tackle the problem of giving LLMs durable, structured agency over complex multi-step tasks.

The common thread is moving beyond simple prompt-response loops toward stateful, role-specialized agent graphs with real-world tool access.

No-Training Performance Gains Through Architectural Tricks: llm-circuit-finder and GraphZero both demonstrate a growing appetite for squeezing more capability out of existing hardware and model weights without expensive retraining.

Whether it’s duplicating transformer layers to boost reasoning or zero-copy memory mapping for GNN training, the community is finding clever systems-level tricks to push boundaries on consumer hardware.

Edge and CPU-First AI Is Gaining Serious Traction: KittenTTS (15M–80M params, CPU-only) and GraphZero (consumer-hardware GNN training) reflect a clear trend toward making AI workloads viable outside the cloud.

Practitioners are increasingly building tools that run on edge devices or laptops, broadening who can deploy AI in production.

👉 I genuinely hope you get value from these articles, if you do, please help me out, leave it a ❤️, and share it with others who would enjoy this. Thank you so much!

👉 My Python Learning Resources

Here are the best resources I have to offer to get you started with Python no matter your background! Check these out as they’re bound to maximize your growth in the field.

Zero to Knowing: Over 1,500+ students have already used this exact system to learn faster, stay motivated, and actually finish what they start.

P.S - Save 20% off your first month. Use code: save20now at checkout!

Try it out now!

Code with Josh: This is my YouTube channel where I post videos every week designed to help break things down and help you grow.

Subscribe on YouTube

My Books: Maybe you’re looking to get a bit more advanced in Python. I’ve written 3 books to help with that, from Data Analytics, to SQL all the way to Machine Learning.

View my eBooks

My Favorite Books on Amazon:

• Python Crash Course - Here

• Automate the Boring Stuff - Here

• Data Structures and Algorithms in Python - Here

• Python Pocket Reference - Here

Hope you all have an amazing week nerds ~ Josh (Chief Nerd Officer 🤓)

👉 If you’ve been enjoying these lessons, consider subscribing to the premium version. You’ll get full access to all my past and future articles, all the code examples, extra Python projects, and more.

Over the past decade, REST APIs have become the most common way developers build distributed systems.

They are simple to understand, stateless by design, and follow a clear request and response pattern. Because of that, they work well for a wide range of applications.

In a typical REST setup, the client has to ask the server for information. The client sends a request, and the server responds with data. When the client wants to know if something has changed, it has to ask again.

This pattern is called polling. An application keeps sending requests at regular intervals just to check if new data is available.

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

Polling works fine in many situations, but it starts to break down when systems need to react to events right away.

As systems grow and more services begin talking to each other, this limitation becomes more obvious. REST works best when the client knows exactly when it needs information.

It does not work as well when the server needs to notify the client that something has happened. That is where webhooks come in.

In this article, I’ll look at why REST by itself is often not enough for modern integrations, how webhooks solve a completely different kind of problem, and when they should be used in real systems.

Along the way, I’ll walk through practical Python examples and real world scenarios that make the difference between these two approaches much easier to understand.

Learning this distinction is an important step toward understanding event driven architecture.

If a project feels heavy in Python, it is usually because it really is heavy.

👉 Premium readers can access all the content and videos.

👉 Access Monthly Python Projects.

👉 Gain access to my full article archive.

👉 and Recommend projects at the bottom.

If you haven’t subscribed to my premium content yet, you need to check it out. You unlock exclusive access to all of these articles and all the code that comes with them, so you can follow along!

Plus, you’ll get access to so much more, like monthly Python projects, in-depth weekly articles, the ‘3 Randoms’ series, and my complete archive!

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work.

Subscribe now

If you get value from my work, consider joining premium. It really helps me keep going and lets me know you’re getting something out of my work!

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

👉 If you get value from my work, please help me out, leave it a ❤️, and share it with others who would benefit from this. Thank you so much!

P.S - Will you learn Python to level up your career? - If yes, click me.

The Concept of Event-Driven Integration

Read more

Agent systems aren’t just getting smarter. They’re getting structured. Memory is no longer an afterthought. Context is becoming an architecture problem. And efficiency is starting to matter just as much as capability.

There’s a clear shift happening:

Less experimentation. More systems you could actually deploy.

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

Instead of isolated tools, we’re seeing full stacks emerge — orchestration layers, memory systems, context engines, and even new ways to train and run models cheaply.

If you’re building AI systems in Python right now, these aren’t just interesting repos. They’re signals.

Let’s get into the 7 most important ones this week.

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work by joining as a premium reader today.

Subscribe now

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

My Python Masterclass now includes 1:1 Live Coaching - Join the Masterclass Here.

👉 I genuinely hope you get value from these articles, if you do, please help me out, leave it a ❤️, and share it with others who would enjoy this. Thank you so much!

This Week’s Trending Repo’s and Tools

1. deer-flow

Repo - Here

What it does: DeerFlow is an open-source super-agent harness from ByteDance that coordinates sub-agents, long-term memory, sandboxed code execution, and extensible skills to handle tasks ranging from deep research to multi-step coding.

Version 2.0 is a full rewrite introducing standardized skill structures and context engineering. It integrates with Slack and Telegram for conversational access.

Why it matters: For Python AI/ML developers building production agent systems, DeerFlow provides a battle-tested, open blueprint from ByteDance that goes far beyond simple LangChain pipelines.

Its modular skill and memory architecture is directly reusable, and its sandbox execution model is critical for safe agentic code running. With 5,200+ stars gained in one week, it’s quickly becoming a reference implementation for serious multi-agent work.

2. OpenViking

Repo - Here

What it does: OpenViking is an open-source context database from Volcengine (ByteDance’s cloud arm) that solves fragmented agent memory by treating all context—memories, resources, and skills—as a unified filesystem.

It supports tiered context loading to minimize token consumption, recursive directory retrieval, and automatic session management for self-iterating agents. Visualized retrieval trajectories make it uniquely observable.

Why it matters: Context management is one of the hardest unsolved problems in production agent development, and OpenViking offers a principled, filesystem-inspired architecture that’s far more structured than ad-hoc vector store approaches.

Python developers building multi-session agents will find its tiered loading and auto-session management directly applicable. At nearly 10k stars with 4,500+ gained this week, it’s attracting serious attention.

Subscribe now

3. nanochat

Repo - Here

What it does: nanochat by Andrej Karpathy is a minimal, single-file harness covering the full LLM lifecycle—tokenization, pretraining, finetuning, evaluation, inference, and a chat UI—optimized to run on a single GPU node.

A GPT-2-equivalent model can be trained for roughly $48. Users specify only model depth; all other hyperparameters are auto-tuned.

Why it matters: Karpathy’s projects consistently become canonical learning resources and practical baselines for the Python ML community.

nanochat’s radical simplicity and cost efficiency make it the definitive starting point for anyone wanting to understand or experiment with LLM training without a cloud budget.

Its hackable codebase is also ideal for researchers who want a clean substrate to test new ideas.

Learn Python With Confidence — With Personal 1:1 Coaching

Stop jumping between tutorials. This is a mentorship-based Python program built to help you actually understand what you’re doing and make steady progress.

I’m teaching you the exact system I’ve refined with 1,500+ students over the last 4+ years — now paired with exclusive 1:1 coaching.

A complete learning path with lifetime access, real-world projects, and six private 1:1 coaching sessions focused on your goals and your code.

One Payment. Lifetime Access. No Rigid Schedule.

👉 Ready to get started?

Get Started Today

4. BitNet

Repo - Here

What it does: BitNet is Microsoft’s official inference framework for 1-bit large language models, featuring optimized CPU and GPU kernels that enable lossless inference at dramatically reduced compute cost.

It achieves up to 6.17x speedup and 82.2% energy reduction on x86 CPUs. Recent updates add concurrent kernel implementations and embedding quantization support.

Why it matters: Running capable LLMs on commodity CPUs without GPUs is a game-changer for edge deployment, cost-sensitive applications, and on-device AI—all areas where Python developers are increasingly being asked to deliver.

BitNet’s sustained momentum (4,700+ stars this week, 34k total) signals that 1-bit inference is crossing from research curiosity to production-viable technology that Python ML engineers need in their toolkit.

5. notebooklm-py

Repo - Here

What it does: notebooklm-py is an unofficial Python library and CLI that exposes the full Google NotebookLM API programmatically, including features unavailable in the web interface such as batch downloads and advanced content generation.

It integrates directly as an agentic skill for Claude Code, Codex, and other AI agents. Users can create notebooks, add sources, and trigger generation of audio, video, or quizzes from Python scripts.

Why it matters: NotebookLM has quietly become a powerful research and content generation backend, but its walled web UI limits automation.

This library unlocks it for Python developers building research pipelines, RAG preprocessing, or agentic workflows that need document understanding at scale.

Gaining 2,292 stars in one week for a relatively niche tool signals strong unmet demand.

Subscribe now

6. hindsight

Repo - Here

What it does: Hindsight is an agent memory system from Vectorize that goes beyond simple retrieval—it enables agents to learn and reflect on past interactions rather than just recall them verbatim.

It claims state-of-the-art performance on LongMemEval benchmarks and integrates via a simple Python API compatible with existing LLM clients. It can be deployed via Docker for both standalone and server configurations.

Why it matters: Most production agent memory implementations are brittle vector store lookups that don’t improve over time; Hindsight’s ‘learning’ architecture is a meaningful step toward agents that actually get better with use.

Python developers building personalized AI assistants or long-running agent systems will find the LLM Wrapper integration path extremely low-friction. Its benchmark-backed claims give it credibility in a space full of vague memory solutions.

7. Understudy

Repo - Here

What it does: Understudy is a desktop automation agent that records a single human demonstration of a task and then learns to reproduce it autonomously going forward.

It requires no scripting or explicit workflow definition—the agent infers the automation from observation. This brings one-shot imitation learning to everyday desktop workflows.

Why it matters: One-shot task learning for desktop automation is a practical leap beyond brittle RPA scripts and closes the gap between LLM reasoning and real-world computer use.

For Python AI/ML developers building or evaluating computer-use agents, Understudy is a concrete, working reference point. Its 114-point HN score on a Show HN reflects strong practitioner interest in agent-driven desktop automation.

Subscribe now

Key Patterns Noted

Agent Memory & Context Management Goes Mainstream: Multiple high-traction projects this week—MiroFish, OpenViking, Hindsight, and deer-flow—center on giving agents structured, self-evolving memory and context management. The shift is from stateless LLM calls to agents that retain, retrieve, and reason over past interactions at scale.

Multi-Agent Orchestration Frameworks Proliferating: deer-flow (ByteDance), MiroFish, and BettaFish all demonstrate multi-agent orchestration pushing beyond single-agent pipelines into hierarchical, sandboxed, or swarm-based coordination. Developers are building full ‘agent harnesses’ rather than simple prompt chains.

Extreme Efficiency: 1-bit LLMs and Sub-$100 Training: Microsoft’s BitNet continues gaining momentum, and projects like nanochat push toward maximally efficient, minimal-cost LLM training and inference. The trend is democratizing serious LLM work—training GPT-2-class models for ~$48 and running 1-bit LLMs on CPUs—making AI accessible without enterprise hardware.

👉 My Python Learning Resources

Here are the best resources I have to offer to get you started with Python no matter your background! Check these out as they’re bound to maximize your growth in the field.

Zero to Knowing: Over 1,500+ students have already used this exact system to learn faster, stay motivated, and actually finish what they start.

P.S - Save 20% off your first month. Use code: save20now at checkout!

Try it out now!

Code with Josh: This is my YouTube channel where I post videos every week designed to help break things down and help you grow.

Subscribe on YouTube

My Books: Maybe you’re looking to get a bit more advanced in Python. I’ve written 3 books to help with that, from Data Analytics, to SQL all the way to Machine Learning.

View my eBooks

My Favorite Books on Amazon:

• Python Crash Course - Here

• Automate the Boring Stuff - Here

• Data Structures and Algorithms in Python - Here

• Python Pocket Reference - Here

Hope you all have an amazing week nerds ~ Josh (Chief Nerd Officer 🤓)

👉 If you’ve been enjoying these lessons, consider subscribing to the premium version. You’ll get full access to all my past and future articles, all the code examples, extra Python projects, and more.

But if you stop and ask what that really means, most people struggle to explain it clearly.

To understand what makes an API stateless, we first need to understand what state actually is.

Basically state is memory. It is information the server keeps about a client between requests. Once you see it that way, the idea of statelessness becomes much clearer. A stateless API does not remember you. Every request stands on its own.

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

That one design decision changes a lot. It affects how you structure your backend. It changes how you handle authentication. It shapes how you scale your system when traffic grows. It even impacts how you think about security and reliability.

Modern systems are expected to handle thousands or even millions of requests without slowing down or falling apart. To do that, they need to be simple to scale and easy to recover when something fails.

Stateless APIs play a huge role in making that possible. When we design APIs without relying on server-side memory, we make it easier to add more servers, recover from crashes, and keep performance steady under load.

This is not about syntax or which framework you prefer. It is not about trendy tools. This is about architecture. The deeper structure that determines whether your system will hold up when it grows.

So let’s walk through it step by step and make it clear.

👉 Premium readers can access all the content and videos.

👉 Access Monthly Python Projects.

👉 Gain access to my full article archive.

👉 and Recommend projects at the bottom.

If you haven’t subscribed to my premium content yet, you need to check it out. You unlock exclusive access to all of these articles and all the code that comes with them, so you can follow along!

Plus, you’ll get access to so much more, like monthly Python projects, in-depth weekly articles, the ‘3 Randoms’ series, and my complete archive!

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work.

Subscribe now

If you get value from my work, consider joining premium. It really helps me keep going and lets me know you’re getting something out of my work!

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

👉 If you get value from my work, please help me out, leave it a ❤️, and share it with others who would benefit from this. Thank you so much!

P.S - Will you learn Python to level up your career? - If yes, click me.

What Statelessness in APIs Actually Means

Read more

It is a Python library focused on one clear job. It takes messy input data and turns it into structured, reliable data you can actually trust. And it does this without forcing you to write a bunch of messy if statements all over your code.

Data flows in from APIs, forms, databases, or direct user input. Marshmallow checks that data, cleans it up, makes sure it follows the rules you set, and shapes it exactly how you want it.

It also handles turning Python objects into JSON and JSON back into Python objects in a way that feels clean and organized instead of chaotic.

Welcome to Marshmellow. Check out other 3 Random Articles here.

Imagine you’re subscribed to a newsletter called 3 Randoms. Each week, it introduces you to three lesser-known Python tools that can make your coding better. It’s like expanding your toolbox and discovering new tricks.

Subscribe now

It gives you a simple way to define schemas that describe what your data should look like. You can define fields, mark them as required, validate formats like emails or URLs, clean up inputs, and even customize the error messages your app returns.

Whether you are building a Flask API, working with FastAPI, loading configuration files, or cleaning data before storing it, Marshmallow helps keep everything consistent and predictable.

The first time you see schemas and nested fields, you might wonder if it is overkill. I had that thought too. But once your project grows past a few routes or a few data models, you start to see why it matters. It becomes the layer that keeps your app stable as it scales.

And it is not limited to simple data. It handles nested objects, lists of complex data, custom validation rules, pre-processing steps, and post-processing transformations. It works just as well in a small script as it does in a production API.

Today, I am going to walk you through three practical features in Marshmallow that can seriously improve how you handle data. You will see how to define schemas, validate input cleanly, and serialize data properly without repeating yourself.

If you do not have it installed yet, open your terminal and run:

pip3 install marshmallow

That is it. Let’s tighten up your data layer and make your application feel solid from the inside.

Thank you guys for allowing me to continue to do work that I find meaningful. This is my full time job so I hope you will support my work. You can now subscribe on the substack app!

Subscribe now

My premium readers get access to so much more, like monthly Python projects, in-depth weekly articles, this here ‘3 Randoms’ series, and my complete archive!

👉 If you get value from my work, please leave it a ❤️ and share it. This helps more people discover this newsletter, which helps me out immensely!

This Week’s Marshmellow Tips

Read more

You can tell…

Read more

APIs move data between services, check who you are, process payments, and expose the core logic of a product to the outside world.

Since APIs are built for machines to talk to each other, they have also become one of the biggest targets in modern software.

When APIs are not locked down properly, attackers do not need some advanced zero day exploit. They go after the basics. They look for simple, predictable weaknesses.

So today I wanted to take some time to actually look at and talk about how certain people can exploit these API’s and some ways you can actually make them better.

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

They automate requests. They test different IDs. They watch how the system responds. Then they push further.

In this article, we are going to break down five real ways hackers take advantage of poorly secured APIs. We will also walk through practical steps your engineering team can use right away to tighten things up.

👉 Premium readers can access all the content and videos.

👉 Access Monthly Python Projects.

👉 Gain access to my full article archive.

👉 and Recommend projects at the bottom.

If you haven’t subscribed to my premium content yet, you need to check it out. You unlock exclusive access to all of these articles and all the code that comes with them, so you can follow along!

Plus, you’ll get access to so much more, like monthly Python projects, in-depth weekly articles, the ‘3 Randoms’ series, and my complete archive!

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work.

Subscribe now

If you get value from my work, consider joining premium. It really helps me keep going and lets me know you’re getting something out of my work!

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

Join the Memory Genesis Competition 2026 to win up to $80,000+ in prize pool

This isn’t a hackathon. This is production-level engineering with real impact.

👉 If you get value from my work, please help me out, leave it a ❤️, and share it with others who would benefit from this. Thank you so much!

P.S - Will you learn Python to level up your career? - If yes, click me.

5 Tips to Strengthen your API’s

Read more

Before long, the logs turn into a mess. They are inconsistent, hard to read, and not very helpful when something actually breaks.

Structlog is a Python library built around a simple idea. Logs should be data, not just text. Instead of writing long log messages and hoping they make sense later, structlog has you log clear key value information that both people and machines can understand.

Welcome to structlog. Check out other 3 Random Articles here.

Imagine you’re subscribed to a newsletter called 3 Randoms. Each week, it introduces you to three lesser-known Python tools that can make your coding better. It’s like expanding your toolbox and discovering new tricks.

Subscribe now

The result is cleaner logs, easier debugging, and systems that are much easier to work with as they grow.

At first, structlog can feel a bit unfamiliar. It does not look or behave exactly like the logging setup most people are used to. I will be honest, it took me some time before it really clicked.

But once it does, it is hard to go back. Your logs become consistent, searchable, and actually useful instead of something you scroll past and ignore.

In this article, we are keeping things simple. I will introduce structlog, explain how structured logging works in plain terms, and walk through three useful patterns that make structlog a solid upgrade over traditional logging.

If your logs have ever let you down right when you needed them most, this is for you.

Let’s get you set up with a quick terminal run:

pip3 install firefly

Thank you guys for allowing me to continue to do work that I find meaningful. This is my full time job so I hope you will support my work. You can now subscribe on the substack app!

Subscribe now

My premium readers get access to so much more, like monthly Python projects, in-depth weekly articles, this here ‘3 Randoms’ series, and my complete archive!

👉 If you get value from my work, please leave it a ❤️ and share it. This helps more people discover this newsletter, which helps me out immensely!

This Week’s Structlog Tips

Read more

There are fewer “cool demo” proj…

Read more

Every small change takes too long to try out. Running the script feels like a whole event instead of a quick test.

You pause before hitting run because you already know you are going to be waiting. The computer seems to be struggling with something that looks simple on the surface.

Most of the time, people blame Python. Or pandas. Or the size of the dataset.

That reaction makes sense. But it is usually not the real issue.

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

Early on, performance problems in data work are not really about raw CPU speed. They are about friction. They come from making the computer do work it does not need to do.

They come from moving too much data around. They come from how the code is structured.

The biggest improvements usually do not come from fancy tricks or new tools. They come from thinking about the problem differently.

Most slow data code is not wrong. It is just shaped the wrong way.

👉 Premium readers can access all the content and videos.

👉 Access Monthly Python Projects.

👉 Gain access to my full article archive.

👉 and Recommend projects at the bottom.

If you haven’t subscribed to my premium content yet, you need to check it out. You unlock exclusive access to all of these articles and all the code that comes with them, so you can follow along!

Plus, you’ll get access to so much more, like monthly Python projects, in-depth weekly articles, the ‘3 Randoms’ series, and my complete archive!

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work.

Subscribe now

If you get value from my work, consider joining premium. It really helps me keep going and lets me know you’re getting something out of my work!

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

👉 If you get value from my work, please help me out, leave it a ❤️, and share it with others who would benefit from this. Thank you so much!

P.S - Will you learn Python to level up your career? - If yes, click me.

Read more

And honestly, that’s fine. Until it’s not. That’s where ujson comes in.

Ujson, short for UltraJSON, is a fast JSON library written in C and built for performance. It does the same job as Python’s standard json module, but it runs noticeably faster, especially when you are working with large chunks of data or parsing JSON over and over again in a loop.

Welcome to ujson. Check out other 3 Random Articles here.

Imagine you’re subscribed to a newsletter called 3 Randoms. Each week, it introduces you to three lesser-known Python tools that can make your coding better. It’s like expanding your toolbox and discovering new tricks.

Subscribe now

The easiest way to think about ujson is as a drop in upgrade. The concepts are the same. The usage feels the same. You just spend less time waiting on JSON to finish its work.

What I like most about ujson is how little it asks from you. There is no new way of thinking about JSON. No complicated setup. You still load, dump, serialize, and deserialize data the same way you always have.

The real difference is that ujson is tuned for speed, which makes it a great fit for data pipelines, web services, scraping jobs, and any script where performance actually matters.

In this article, we are going to look at ujson and then walk through three practical functions that show where it’s good and how you can start using it right away.

If you work with APIs, scrape data, or move a lot of structured data around, this is one tool you will be glad you know about.

Let’s get you set up with a quick terminal run:

pip3 install ujson

If you spend most of your day in the terminal like I do, this one is going to be fun.

Thank you guys for allowing me to continue to do work that I find meaningful. This is my full time job so I hope you will support my work. You can now subscribe on the substack app!

Subscribe now

My premium readers get access to so much more, like monthly Python projects, in-depth weekly articles, this here ‘3 Randoms’ series, and my complete archive!

👉 If you get value from my work, please leave it a ❤️ and share it. This helps more people discover this newsletter, which helps me out immensely!

This Week’s Ujson Tips

Read more

It is a Python library that helps you understand what is actually going wrong in your app, not just that something failed.

At a basic level, sentry-sdk gives you real time error tracking and performance tracking. Instead of digging through logs or trying to recreate a bug on your laptop, Sentry shows you what happened, where it happened, and what led up to it.

Welcome to sentry-sdk. Check out other 3 Random Articles here.

Imagine you’re subscribed to a newsletter called 3 Randoms. Each week, it introduces you to three lesser-known Python tools that can make your coding better. It’s like expanding your toolbox and discovering new tricks.

Subscribe now

You can see stack traces, variable values, what the app was doing right before the error, and even which parts of your code are running slowly, all in one place.

I think of sentry-sdk as having eyes inside your production app. It sits quietly in the background while your code runs and lets you know the moment something feels off.

If an error happens, you see it right away. If a request suddenly slows down, you can tell exactly where the time is going. When you check later, the context is already there waiting for you.

The best part is how easy it is to set up. With just a few lines of code, Sentry starts catching errors automatically.

From there, you can add performance tracking, custom events, and extra details only where you need them. It works well for web apps, APIs, background jobs, and even small scripts where you just want to know what is happening.

In this article, we look at three practical features you can use right away to get better visibility, spend less time debugging, and catch problems before users start noticing them.

Let’s get you set up with a quick terminal run:

pip3 install sentry-sdk

If you spend most of your day in the terminal like I do, this one is going to be fun.

Thank you guys for allowing me to continue to do work that I find meaningful. This is my full time job so I hope you will support my work. You can now subscribe on the substack app!

Subscribe now

My premium readers get access to so much more, like monthly Python projects, in-depth weekly articles, this here ‘3 Randoms’ series, and my complete archive!

👉 If you get value from my work, please leave it a ❤️ and share it. This helps more people discover this newsletter, which helps me out immensely!

This Week’s Sentry-SDK Tips

Read more

Read more

Still, a lot of people hit the same wall and start asking the same question. Why do my Python projects feel harder than they should?

The frustration usually sneaks in. A script that should take one afternoon turns into a full week. You open your editor and feel stuck instead of excited. Nothing is broken, but nothing feels clear either.

This is very common, especially for self taught developers or people moving from tutorials into real projects. The problem is almost never about being smart enough or not trying hard enough. Most of the time, it is mental overload.

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

When a Python project feels draining before it feels useful, the issue is not ability. The project is simply asking your brain to hold too much at once.

You are juggling assumptions, abstractions, future ideas, and things you might need later, all at the same time. Your brain pushes back against that kind of pressure.

Python makes this tension obvious. Its simplicity does not hide messy structure. In more verbose languages, complexity can get buried under extra syntax and patterns. Python puts it right in your face.

If a project feels heavy in Python, it is usually because it really is heavy.

👉 Premium readers can access all the content and videos.

👉 Access Monthly Python Projects.

👉 Gain access to my full article archive.

👉 and Recommend projects at the bottom.

If you haven’t subscribed to my premium content yet, you need to check it out. You unlock exclusive access to all of these articles and all the code that comes with them, so you can follow along!

Plus, you’ll get access to so much more, like monthly Python projects, in-depth weekly articles, the ‘3 Randoms’ series, and my complete archive!

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work.

Subscribe now

If you get value from my work, consider joining premium. It really helps me keep going and lets me know you’re getting something out of my work!

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

👉 If you get value from my work, please help me out, leave it a ❤️, and share it with others who would benefit from this. Thank you so much!

P.S - Will you learn Python to level up your career? - If yes, click me.

Read more

These are n…

Read more

Firefly is a Python library that lets you build clean, interactive dashboards and charts right inside your terminal. No browser. No web app. Just clear visuals, live updates, and a surprisingly polished experience in the place you already work every day.

It turns boring terminal output into something you can understand at a glance. Charts update in real time. Tables feel responsive. Dashboards finally look like dashboards.

Welcome to firefly. Check out other 3 Random Articles here.

Imagine you’re subscribed to a newsletter called 3 Randoms. Each week, it introduces you to three lesser-known Python tools that can make your coding better. It’s like expanding your toolbox and discovering new tricks.

Subscribe now

The easiest way to think about Firefly is this. It gives your terminal eyes. Instead of dumping numbers and hoping your brain connects the dots, you can see trends, progress, and system state right where your code runs. That alone changes how you debug, monitor, and explore data.

I did not expect to like it as much as I do. Most terminal tools get the job done but look rough. Firefly breaks that pattern. It feels thoughtful, well designed, and genuinely useful. Once you try it, going back to plain print statements feels old.

In this article, we are digging into Firefly and walking through three features that show how powerful terminal dashboards can be. No filler. Just practical examples you can drop straight into your workflow.

Let’s get you set up with a quick terminal run:

pip3 install firefly

If you spend most of your day in the terminal like I do, this one is going to be fun.

Thank you guys for allowing me to continue to do work that I find meaningful. This is my full time job so I hope you will support my work. You can now subscribe on the substack app!

Subscribe now

My premium readers get access to so much more, like monthly Python projects, in-depth weekly articles, this here ‘3 Randoms’ series, and my complete archive!

👉 If you get value from my work, please leave it a ❤️ and share it. This helps more people discover this newsletter, which helps me out immensely!

This Week’s Firefly Tips

Read more

You stare at the diff and think there is no way that tiny change caused thi…

Read more

This is why people just talk about it as “the everything language”.

On the surface, that sounds amazing. In real life, it usually just creates confusion.

When beginners hear that Python can do everything, they expect it to be the right tool for every job. When experienced devs hear the same thing, they sometimes push Python into places where it does not really belong.

That is when you start seeing slow systems, rubbish designs, and a lot mistakes. Most of the time, those mistakes are not Python’s fault.

Every week you’ll be introduced to a new topic in Python, think of this as a mini starter course to get you going and allow you to have a structured roadmap that actually builds to create you a solid foundation in Python. Join us today!

Subscribe now

Python is a great language. But it does have a point of view, even if it is not loud about it. It cares more about code being easy to read than being clever.

This article is about setting boundaries. Not to box Python in, but to respect what it is built for. When you know what Python is truly good at, your projects feel simpler and cleaner. When you know what it is not good at, your system designs get smarter.

👉 Premium readers can access all the content and videos.

👉 Access Monthly Python Projects.

👉 Gain access to my full article archive.

👉 and Recommend projects at the bottom.

If you haven’t subscribed to my premium content yet, you need to check it out. You unlock exclusive access to all of these articles and all the code that comes with them, so you can follow along!

Plus, you’ll get access to so much more, like monthly Python projects, in-depth weekly articles, the ‘3 Randoms’ series, and my complete archive!

Thank you guys for allowing me to do work that I find meaningful. This is my full-time job so I hope you will support my work.

Subscribe now

If you get value from my work, consider joining premium. It really helps me keep going and lets me know you’re getting something out of my work!

If you’re already a premium reader, thank you from the bottom of my heart! You can leave feedback and recommend topics and projects at the bottom of all my articles.

👉 If you get value from my work, please help me out, leave it a ❤️, and share it with others who would benefit from this. Thank you so much!

P.S - Will you learn Python to level up your career? - If yes, click me.

Read more

JAX is a Python library that feels a lot like NumPy. You write the same kind of array code you already know. The difference is what happens behind the scenes. JAX is designed to run well on modern hardware like GPUs and TPUs. It also supports automatic differentiation and just in time compilation, without forcing you to rewrite your code from scratch.

If you have ever used NumPy and thought, this works great but I wish it were faster or easier to scale, JAX feels like the obvious next step. You keep writing familiar array based code, and JAX handles the heavy lifting. It moves work to accelerators and optimizes performance for you.

Welcome to Jax. Check out other 3 Random Articles here.

Imagine you’re subscribed to a newsletter called 3 Randoms. Each week, it introduces you to three lesser-known Python tools that can make your coding better. It’s like expanding your toolbox and discovering new tricks.

Subscribe now

What really makes JAX stand out is how cleanly it brings a few powerful ideas together. You get NumPy style APIs that feel natural. You get automatic differentiation, which makes working with gradients simple. And you get compilation through XLA, which can make your code much faster with very little extra work.

In this article, we are diving into JAX and looking at three practical features that show why so many people are moving past plain NumPy. No heavy theory. No vague explanations. Just clear examples that show how JAX works and when it makes sense to use it.

If you like clean math, fast code, and tools that can grow with you, this is worth checking out.

Let’s get it install via your terminal with pip:

pip3 install jax

Thank you guys for allowing me to continue to do work that I find meaningful. This is my full time job so I hope you will support my work. You can now subscribe on the substack app!

Subscribe now

My premium readers get access to so much more, like monthly Python projects, in-depth weekly articles, this here ‘3 Randoms’ series, and my complete archive!

👉 If you get value from my work, please leave it a ❤️ and share it. This helps more people discover this newsletter, which helps me out immensely!

This Week’s Jax Tips

Read more