<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rudra Prasad Bhuyan on Medium]]></title>
        <description><![CDATA[Stories by Rudra Prasad Bhuyan on Medium]]></description>
        <link>https://medium.com/@rudraprasadbhuyan999?source=rss-53d039b2c456------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*2Hz5LHkDqdLZKkrmJw2xng.png</url>
            <title>Stories by Rudra Prasad Bhuyan on Medium</title>
            <link>https://medium.com/@rudraprasadbhuyan999?source=rss-53d039b2c456------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 23:34:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rudraprasadbhuyan999/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[From 6 GB to 113.7 TB: What Working With a Massive Dataset Taught Me]]></title>
            <link>https://blog.stackademic.com/from-6-gb-to-113-7-tb-what-working-with-a-massive-dataset-taught-me-4c1918d2826b?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c1918d2826b</guid>
            <category><![CDATA[data-pipeline]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 10:38:31 GMT</pubDate>
            <atom:updated>2026-10-26T10:38:31.071Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dh5wboFFA9JPfp-fvOZrfA.png" /><figcaption>Made by Author</figcaption></figure><p>A few months ago, working with a <strong>6 GB dataset</strong> felt big to me.</p><p>Recently, while building a personal machine learning project, I came across a dataset with a completely different scale:</p><p><strong>The Stack v3 — a 113.7 TB source corpus.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/879/1*PsIfGP7qMgUK8ucTlsEZ-A.png" /></figure><p>That is almost <strong>19,000× larger</strong> than the 6 GB datasets I had worked with before.</p><p>And that changed the way I thought about data engineering.</p><h3>It Started With a Fine-Tuning Project</h3><p>My actual goal was simple.</p><p>I wanted to fine-tune a model for a personal project, and for that, I needed good training data.</p><p>While searching on Hugging Face, I found <strong>The Stack v3</strong>, a massive collection of source code.</p><p>At first, seeing more data sounded great.</p><p>More data means more possibilities, right?</p><p>But very quickly, I realized that with a dataset this large, the problem isn’t:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1e72Y15OM2NnnEBexuEfKA.png" /><figcaption>Made by Author</figcaption></figure><p>That was a very different problem.</p><h3>First Problem: Understanding What Was Inside</h3><p>The dataset was stored mainly in <strong>Parquet files</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*menwu8Ot9okDYBx8p56FjA.png" /></figure><p>I had worked with CSV and smaller datasets before, where I could simply open the file and start exploring it.</p><p>That wasn’t realistic here.</p><p>So instead of touching the whole dataset, I started with a small sample.</p><p>I took a small portion of the data and converted only that sample into something I could easily inspect in Excel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*fE85rmCqQ_GYmVzOOsW8MQ.png" /><figcaption>Made by Author</figcaption></figure><p>This helped me understand:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1015/1*mReXllVl-VLByn2Py3Gjgg.png" /><figcaption>Made by Author</figcaption></figure><p>This small step saved me from designing a pipeline around assumptions.</p><h3>Don’t Process What You Don’t Need</h3><p>Once I understood the structure, the next question was:</p><p><strong>What data do I actually need for fine-tuning?</strong></p><p>Instead of trying to collect everything, I started designing a pipeline around filtering.</p><p>The rough flow became:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*TOCPFCdg9tHur44Xdll3vA.png" /><figcaption>Made by Author</figcaption></figure><p>The idea was simple.</p><p>Take one manageable chunk.</p><p>Process it.</p><p>Keep what is relevant.</p><p>Discard what isn’t.</p><p>Then move to the next chunk.</p><p>I didn’t need 113.7 TB.</p><p>I needed the <strong>right small portion of 113.7 TB</strong>.</p><p>That difference became one of my biggest lessons from the project.</p><h3>Then Came Another Problem:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/985/1*DrOo6EUNTTn8VYJk_JL3UA.png" /></figure><p>Processing large amounts of data can take a long time.</p><p>And things fail.</p><p>The machine may restart.</p><p>The script may crash.</p><p>The network may disconnect.</p><p>I might simply want to stop the process and continue later.</p><p>Restarting everything from zero would waste a huge amount of time.</p><p>So I added <strong>checkpoints</strong>.</p><p>After completing parts of the processing, the pipeline saves its progress.</p><p>When I run it again, instead of starting from the beginning, it can continue from where it stopped.</p><p>For smaller datasets, I had rarely thought seriously about this.</p><p>At larger scales, resumability becomes part of the system design.</p><h3>The Biggest Thing I Learned</h3><p>Moving from a 6 GB dataset to working with a <strong>113.7 TB source corpus</strong> didn’t just teach me how to deal with larger files.</p><p>It changed how I think about data.</p><p>With smaller datasets, sometimes we can get away with:</p><p><strong>Load everything → Explore → Process</strong></p><p>With massive datasets, the thinking becomes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*t8Ujti8mw8s3fbuUhnLZPg.png" /><figcaption>Made by Author</figcaption></figure><p>The goal isn’t to prove that you can process everything.</p><p>The goal is to design the system so that <strong>you don’t have to</strong>.</p><p>After sampling, chunking, filtering, and reducing the dataset to something relevant to my requirements, I could finally move to the part I originally wanted to work on: <strong>Fine-tuning the model.</strong></p><p>That will be the next part of this story.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c1918d2826b" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/from-6-gb-to-113-7-tb-what-working-with-a-massive-dataset-taught-me-4c1918d2826b">From 6 GB to 113.7 TB: What Working With a Massive Dataset Taught Me</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How a Few YAML Files Saved Me Hours of Work and Wasted GPU Money During Fine-Tuning]]></title>
            <link>https://blog.stackademic.com/how-a-few-yaml-files-saved-me-hours-of-work-and-wasted-gpu-money-during-fine-tuning-833f0548e640?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/833f0548e640</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[fine-tuning]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 10:28:37 GMT</pubDate>
            <atom:updated>2026-10-26T10:28:37.445Z</atom:updated>
            <content:encoded><![CDATA[<h4>I used to think configuration files were just project housekeeping. Fine-tuning a model changed my mind.</h4><p>When I first started working on machine learning projects, I did what many beginners naturally do.</p><p>I put configuration values directly inside the code.</p><p>Learning rate? Hardcoded.</p><p>Batch size? Hardcoded.</p><p>Checkpoint settings? Somewhere inside another Python file.</p><p>Hugging Face repository information? Somewhere else.</p><p>Logging settings? Another file.</p><p>It worked.</p><p>And because it worked, I didn’t immediately see the problem.</p><p>The problem only became obvious when the project became bigger.</p><p>Suddenly, changing one parameter wasn’t really changing one parameter anymore.</p><p>I had to ask myself:</p><blockquote><em>Where else is this value being used?</em></blockquote><p>In an industry-grade codebase with hundreds or thousands of lines of code, that question becomes painful very quickly.</p><p>A small experiment could mean searching through several files, checking that I hadn’t missed another dependency, modifying the value, running the pipeline, and then discovering that something else was still using the old configuration.</p><p>Sometimes a change that should have taken a minute could consume around 10 minutes.</p><p>When you have hundreds of parameters spread across model configuration, logging, monitoring, data processing, checkpoints, guardrails, and infrastructure, the total configuration work can easily become hours.</p><p>In my case, I was dealing with more than <strong>250 configuration-related values</strong> across the fine-tuning system.</p><p>Manually preparing or changing everything could easily cost me around <strong>two hours</strong> before the actual training even became the interesting part.</p><p>Then I started treating YAML differently.</p><p>Not as a place to dump some parameters.</p><p>But as the <strong>control layer of the entire fine-tuning pipeline</strong>.</p><p>And that changed the way I worked.</p><h3>The problem wasn’t Python. It was configuration ownership.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W7vjdA29mL_oSwL410Nmug.png" /></figure><p>Imagine this simplified situation:</p><pre>learning_rate = 0.00002<br>batch_size = 4<br>max_epochs = 10<br>save_steps = 500</pre><p>At first, this feels convenient.</p><p>Everything is right there.</p><p>But eventually another file needs the same value.</p><p>Then another.</p><p>Maybe your training code assumes one checkpoint strategy while your evaluation script assumes another.</p><p>Maybe your local test needs a small model while the AWS training job should use a much larger one.</p><p>Maybe your monitoring configuration changes between environments.</p><p>The code starts knowing too much about the environment in which it is running.</p><p>That was the important lesson for me.</p><p><strong>The pipeline logic and the pipeline configuration are not the same thing.</strong></p><p>The code should know <em>how to train</em>.</p><p>The configuration should tell it <em>how this particular run should behave</em>.</p><p>Once I understood that separation, YAML started becoming much more valuable.</p><h3>I created a dedicated configuration layer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JM8_z3lgXbU6Sa2TV6NcDw.png" /></figure><p>Instead of spreading important values throughout the codebase, I organized them inside a configuration folder.</p><p>Conceptually, my setup had six main areas:</p><pre>configs/<br>│<br>├── guardrails.yaml<br>├── logging.yaml<br>├── model_input.yaml<br>├── model_output.yaml<br>├── model_parameters.yaml<br>└── monitoring.yaml</pre><p>Each file had one responsibility.</p><p>That sounds like a small architectural decision.</p><p>For me, it became one of the most useful decisions in the entire fine-tuning pipeline.</p><h3>1. Guardrails: fail before the expensive part begins</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2wjOMIEaemtypBDoJSsOzw.png" /></figure><p>The first configuration layer is the one I now appreciate the most.</p><p><strong>Guardrails.</strong></p><p>Cloud training changes how you should think about failure.</p><p>If something breaks after two seconds on your laptop, it is annoying.</p><p>If something breaks after hours on a GPU instance, it is annoying <strong>and expensive</strong>.</p><p>So before allowing the expensive part of the pipeline to begin, I want to validate as much as possible.</p><p>For example:</p><ul><li>Are numerical parameters inside allowed ranges?</li><li>Is the dataset available?</li><li>Is tokenization configured correctly?</li><li>Is quantization supported?</li><li>Is enough memory available?</li><li>Is the Hugging Face repository configured?</li><li>Are required API credentials available?</li><li>Is checkpointing configured correctly?</li><li>Is monitoring enabled correctly?</li><li>Are model settings compatible with the environment?</li><li>Are obvious failure conditions already detectable?</li></ul><p>The principle became:</p><blockquote><strong><em>Fail early when failure is cheap.</em></strong></blockquote><p>If my learning rate is invalid, I don’t want AWS to discover that for me after starting an expensive job.</p><p>If my dataset path is broken, I don’t want the GPU waiting while the pipeline crashes.</p><p>If a required repository configuration is missing, training should never start.</p><p>The guardrails become the gatekeeper.</p><h3>2. Logging: every run should leave evidence behind</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tkGa_kQs5Te4axO3XYmJAg.png" /></figure><p>Fine-tuning without good logging becomes surprisingly difficult.</p><p>You remember that “one run performed better.”</p><p>But then you ask:<strong>Why?</strong></p><ul><li>What model was used?</li><li>What configuration?</li><li>Which dataset?</li><li>Which hardware?</li><li>Which checkpoint?</li><li>Which run ID?</li><li>What guardrails were applied?</li><li>What happened before the failure?</li></ul><p>Without structured logging, experiments become memories instead of evidence.</p><p>So I separated logging configuration as well.</p><p>I prefer structured output such as JSON containing information like:</p><pre>timestamp<br>run_id<br>model<br>hardware<br>checkpoint<br>guardrail results<br>training state<br>evaluation state</pre><p>Secrets obviously need to be protected rather than dumped into logs.</p><p>But the broader idea is important:</p><blockquote><em>Every experiment should be reconstructable from evidence.</em></blockquote><p>This becomes especially valuable after running many experiments.</p><h3>3. Model input: clearly define what enters training</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xbvzfL4-9CFbp9h7NvxcXg.png" /></figure><p>Then comes the input side.</p><p>This answers a very simple question:</p><blockquote><em>What exactly am I feeding into the model?</em></blockquote><p>The input configuration can describe things such as:</p><ul><li>dataset location</li><li>dataset split</li><li>tokenization</li><li>preprocessing</li><li>sequence length</li><li>sampling behavior</li><li>formatting</li><li>small test subsets</li></ul><p>Separating this from the training logic helps enormously when experimenting.</p><p>I can change the dataset configuration without rewriting the training pipeline itself.</p><h3>4. Model output: know where everything goes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ep_rFojigdxfh6fy4efKUA.png" /></figure><p>The output side handles what training produces.</p><p>For my workflow, Hugging Face is an important part of this.</p><p>The output configuration can describe things such as:</p><ul><li>checkpoint strategy</li><li>checkpoint frequency</li><li>retention policy</li><li>repository ID</li><li>adapter artifacts</li><li>tokenizer artifacts</li><li>manifests</li><li>final model outputs</li></ul><p>Checkpoint configuration is especially important.</p><p>Training can run for hours.</p><p>I don’t want one interruption to mean starting from zero again.</p><p>The output layer defines how that progress is preserved.</p><h3>5. Model parameters: the heart of experimentation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ep_rFojigdxfh6fy4efKUA.png" /></figure><p>Then comes the section everyone normally thinks about first:</p><p><strong>training parameters.</strong></p><p>Things such as:</p><pre>learning_rate:<br>batch_size:<br>epochs:<br>warmup:<br>gradient_accumulation:<br>quantization:<br>early_stopping:</pre><p>The exact values depend on the model, dataset, hardware, and experiment.</p><p>But moving them outside the training code changed my workflow.</p><p>Suppose monitoring tells me the learning rate is too low.</p><p>The model is barely learning.</p><p>Previously, I might need to find where that value was defined in the code.</p><p>Then check whether another part of the pipeline overrides it.</p><p>Then modify it carefully.</p><p>With the configuration layer, I already know where to look.</p><p>I change the configuration.</p><p>The implementation stays untouched.</p><p>That sounds almost trivial until you’re doing many experiments.</p><p>Then the saved time compounds quickly.</p><h3>6. Monitoring: graphs are not decoration</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_aUjVdxZ2uW-DNhXFTu2Yw.png" /><figcaption>My Monitoring Page</figcaption></figure><p>Monitoring became another important part of the system.</p><p>During training, I want to understand questions such as:</p><ul><li>Is training loss decreasing?</li><li>Is evaluation loss improving?</li><li>Are the metrics plateauing?</li><li>Is the model actually learning?</li><li>Is something becoming unstable?</li><li>Should this run continue?</li><li>Are we wasting compute?</li></ul><p>This is where configuration starts translating directly into money.</p><p>One of the clearest examples is <strong>early stopping</strong>.</p><h3>Don’t pay for epochs your model doesn’t need</h3><p>Earlier, imagine I planned a training run for: 10 epochs</p><p>Without proper stopping behavior, the job could continue running even when the model had stopped meaningfully improving.</p><p>That means GPU time is still being consumed.</p><p>But the model isn’t giving me meaningful additional value.</p><p>So I added early stopping behavior.</p><p>Conceptually:</p><pre>early_stopping:<br>  enabled: true<br>  patience: 3<br>  metric: eval_loss</pre><p>The exact configuration can vary, but the principle is simple.</p><p>If the model has not meaningfully improved for several evaluations, stop.</p><p>In my case, I think about something like <strong>three consecutive non-improving stages</strong> before deciding the run is no longer worth continuing.</p><p>Instead of blindly running for around 10 hours, some runs could finish around <strong>6–8 hours</strong>, depending on the data and experiment.</p><p>That is potentially <strong>2–4 hours of compute avoided on a single experiment</strong>.</p><p>And that changed how I thought about early stopping.</p><p>It isn’t only an ML technique.</p><p>It is also a <strong>cost-control mechanism</strong>.</p><blockquote><em>If the model has stopped learning, the GPU should probably stop earning.</em></blockquote><h3>The biggest saving came from testing in stages</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tkGa_kQs5Te4axO3XYmJAg.png" /></figure><p>But configuration alone wasn’t enough.</p><p>The next improvement was changing <strong>where I test the pipeline</strong>.</p><p>I now think about fine-tuning in three stages.</p><h3>Stage 1: Local smoke test</h3><p>I don’t immediately throw the full workload onto AWS.</p><p>First, I want to know whether the pipeline fundamentally works.</p><p>On my lower-resource local system, I can use something much smaller — for example, a small model such as a <strong>0.5B parameter model</strong>.</p><p>I am not trying to get the final model here.</p><p>I am testing things like:</p><pre>Can the code start?<br>Can the dataset load?<br>Does tokenization work?<br>Do the configurations resolve?<br>Does training execute?<br>Can checkpoints be created?<br>Does evaluation run?<br>Does the pipeline finish?</pre><p>If something is broken, I want to discover it here.</p><p>Because local failure is cheap.</p><h3>Stage 2: Cloud pilot run</h3><p>Passing locally doesn’t guarantee everything will behave correctly in the cloud.</p><p>So instead of jumping directly into the complete training job, I run a <strong>pilot test</strong>.</p><p>Maybe only: 10–20 samples</p><p>or another deliberately small subset.</p><p>Now I’m verifying the actual AWS environment:</p><ul><li>dependencies</li><li>GPU access</li><li>storage</li><li>credentials</li><li>monitoring</li><li>model downloads</li><li>artifact uploads</li><li>checkpoint behavior</li></ul><p>This stage catches environment-specific failures without committing the full budget.</p><h3>Stage 3: Full cloud training</h3><p>Only after both checks pass do I move to the expensive run.</p><p>The workflow becomes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/967/1*ibhf4IAlgXrItVxgZPaEsg.png" /></figure><p>That simple progression changed the economics of experimentation for me.</p><p>Instead of debugging with an expensive GPU, I debug <strong>before the expensive GPU becomes necessary</strong>.</p><h3>YAML made switching between these modes simple</h3><p>This is where the configuration architecture becomes powerful.</p><p>I don’t want three completely different codebases for:</p><ul><li>local</li><li>pilot</li><li>production training</li></ul><p>I want the same pipeline behaving differently based on configuration.</p><p>Conceptually:</p><pre>profile: local_smoke</pre><p>can become:</p><pre>profile: cloud_pilot</pre><p>and finally:</p><pre>profile: cloud_training</pre><p>The underlying code doesn’t need to be constantly rewritten.</p><p>The behavior changes through configuration.</p><p>That is a much safer mental model.</p><h3>It also gave me more control over coding agents</h3><p>There is another benefit I didn’t fully expect.</p><p>Today, coding agents can modify a lot of code very quickly.</p><p>That’s useful.</p><p>But I don’t necessarily want an agent freely deciding my fine-tuning configuration.</p><p>Parameters such as:</p><pre>learning rate<br>batch size<br>checkpoint policy<br>dataset<br>quantization<br>monitoring<br>output repository<br>early stopping</pre><p>can materially change an experiment.</p><p>So I prefer having a clearly defined configuration layer.</p><p>The code can evolve.</p><p>The agent can help implement features.</p><p>But the experiment-critical values live somewhere explicit and reviewable.</p><p>That gives me a boundary.</p><p>I know where the decisions are.</p><p>And I can review them before spending compute.</p><h3>The time saving became noticeable</h3><p>Before this structure, changing a parameter could sometimes take around <strong>10 minutes</strong> because I needed to locate it and understand what else depended on it.</p><p>Across hundreds of configuration values, properly preparing an experiment could take roughly <strong>two hours</strong>.</p><p>With centralized YAML configuration, much of that hunting disappears.</p><p>Instead of asking:</p><blockquote><em>Where in the codebase is this value hiding?</em></blockquote><p>I ask:</p><blockquote><em>Which configuration file owns this value?</em></blockquote><p>That is a much easier question.</p><p>And when a training run that might have continued for around 10 hours can be stopped around 6–8 hours because monitoring says it is no longer improving, the saving isn’t only developer time anymore.</p><p>It is compute time too.</p><h3>The real lesson wasn’t YAML</h3><p>After all of this, I don’t think the biggest lesson is:</p><blockquote><em>“Use YAML.”</em></blockquote><p>You could use another configuration format.</p><p>The deeper lesson is:</p><blockquote><strong><em>Separate decisions from implementation.</em></strong></blockquote><p>Your Python code contains the mechanism.</p><p>Your configuration contains the decisions for a particular run.</p><p>Your guardrails validate those decisions.</p><p>Your monitoring tells you whether those decisions are working.</p><p>Your early stopping protects you when they aren’t.</p><p>And your testing stages make sure you fail at the cheapest possible point.</p><p>That’s the architecture that saved me time.</p><p>YAML simply made that architecture easy to see and operate.</p><h3>What I would do differently if I started again</h3><p>If I were rebuilding a fine-tuning pipeline from zero today, I would introduce configuration management much earlier.</p><p>I would not wait until the project became large enough to hurt.</p><p>I would separate at least:</p><pre>guardrails<br>logging<br>input<br>output<br>training parameters<br>monitoring</pre><p>from the beginning.</p><p>I would also design three execution profiles immediately:</p><pre>local smoke<br>cloud pilot<br>full training</pre><p>And I would treat early stopping as both an ML decision and an infrastructure decision.</p><p>Because cloud GPUs don’t care whether your model is learning.</p><p>They continue running until <strong>you tell them to stop</strong>.</p><h3>Final thought</h3><p>I started using YAML because I wanted an easier way to change parameters.</p><p>I ended up learning something much bigger.</p><p>Good configuration management isn’t about avoiding a few lines of Python.</p><p>It is about creating a system where experiments are easier to understand, reproduce, control, debug, and stop.</p><p>For me, the progression looked like this:</p><blockquote><strong><em>Hardcoded values → centralized configuration → guardrails → cheap testing → monitored training → early stopping.</em></strong></blockquote><p>And somewhere along that path, YAML stopped being “just a configuration file.”</p><p>It became one of the simplest ways I found to protect both my <strong>time</strong> and my <strong>GPU budget</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=833f0548e640" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/how-a-few-yaml-files-saved-me-hours-of-work-and-wasted-gpu-money-during-fine-tuning-833f0548e640">How a Few YAML Files Saved Me Hours of Work and Wasted GPU Money During Fine-Tuning</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 Software Engineering Lessons I Learned the Hard Way as an AI/ML Engineer]]></title>
            <link>https://ai.plainenglish.io/5-software-engineering-lessons-i-learned-the-hard-way-as-an-ai-ml-engineer-b316bbc15af0?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/b316bbc15af0</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[business]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Sat, 10 Oct 2026 21:34:46 GMT</pubDate>
            <atom:updated>2026-10-10T21:34:46.678Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>I thought delivering good work meant building the right technical solution. I slowly learned that software engineering is also about understanding time, expectations, communication, and what “done” actually means.</blockquote><p>When I started working as an AI/ML engineer, most of my thinking was technical.</p><p>If someone gave me a problem, my natural reaction was:</p><p><strong>Understand the technology → build the solution → make it work.</strong></p><p>That approach works surprisingly well in personal projects.</p><p>In a personal project, I decide the deadline. I decide the interface. I decide what success looks like. If I want to spend three more days experimenting with something, nobody is waiting for me.</p><p>A company project is completely different.</p><p>There is a client.</p><p>There is a deadline.</p><p>There are business requirements.</p><p>There are other engineers depending on your work.</p><p>And sometimes the requirement you understood on Monday is not the requirement that matters three weeks later.</p><p>I learned several of these lessons while working with senior software engineers.</p><p>Some were taught to me directly.</p><p>Some came from mistakes.</p><p>And some became clear only after I had already put a lot of effort into the wrong direction.</p><p>These are the five lessons that changed how I approach software projects.</p><h3>1. Understand the timeline before you understand the technology</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FPY5T8rOVUZwNfjWGU9pzQ.png" /></figure><p>One of the biggest lessons came from a project that originally had roughly <strong>four months of development time</strong>.</p><p>With that timeline in mind, I was thinking about the complete pipeline.</p><p>I was studying the problem, designing the architecture and thinking about how all the pieces would connect.</p><p>For almost three weeks, I worked with that mental model.</p><p>Then we had a meeting.</p><p>Several senior members joined, and during the discussion I learned something important:</p><p><strong>The delivery timeline had changed dramatically.</strong></p><p>What I had mentally treated as a multi-month project had effectively turned into something that needed results within about a month.</p><p>And by that point, three weeks were already gone.</p><p>I essentially had <strong>one week left</strong>.</p><p>That changes everything.</p><p>The technical problem had not magically become easier.</p><p>The amount of time available to solve it had simply become much smaller.</p><p>At that moment, I understood why timeline awareness matters so much in software development.</p><p>Instead of thinking about the entire pipeline, I started breaking the work into smaller components.</p><p>I asked myself:</p><ul><li>What exactly needs to work first?</li><li>Which component is essential?</li><li>What can realistically be completed within the remaining days?</li><li>What do I already understand from previous projects?</li><li>Where will I need help?</li></ul><p>Fortunately, one of the components was similar to something I had already worked on in a personal project.</p><p>That previous experience helped a lot.</p><p>I studied more, worked harder, reorganized the work and focused deeply on that specific component.</p><p>The plan was roughly one week.</p><p>I was able to complete my part by the <strong>fifth day</strong>.</p><p>One additional dependency required cloud access and help from someone else, but the actual work I controlled was completed according to the compressed plan.</p><p>That experience taught me something I did not fully understand before:</p><blockquote><strong><em>The same engineering problem becomes a completely different problem when the timeline changes.</em></strong></blockquote><p>If you have four months, you may optimise for architecture, extensibility and completeness.</p><p>If you have one week, you need to identify the shortest reliable path to the required outcome.</p><p>Now, one of the first things I want to understand when receiving a project is not the framework, model or database.</p><p>It is:<strong>“When does this actually need to be delivered?”</strong></p><h3>2. Understand the problem before solving it</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uWEOvAIVOO8PpuRlFrsTlQ.png" /></figure><p>Another lesson was more painful because technically, I was doing work.</p><p>The problem was that I was doing the wrong work.</p><p>On another project, I was asked to implement a feature.</p><p>From my perspective, the requirement made sense as a <strong>command-line interface</strong>.</p><p>I personally use command-line tools frequently, so my brain automatically started imagining the feature that way.</p><p>I designed the functionality around a CLI.</p><p>I implemented it.</p><p>It worked.</p><p>Then came the demonstration.</p><p>During the meeting, I showed what I had built.</p><p>That was when I realised:</p><p><strong>This was not what my senior expected.</strong></p><p>The expected experience was closer to a <strong>web/UI-based interaction</strong>.</p><p>I had implemented the feature.</p><p>But I had interpreted the product differently.</p><p>That distinction sounds small when written in one sentence.</p><p>When you are the person who spent hours building it, it does not feel small.</p><p>I had put real effort into it.</p><p>The code worked.</p><p>The logic worked.</p><p>The feature existed.</p><p>But the outcome was not the outcome the project needed.</p><p>Eventually, that project moved back to senior engineers while I shifted to another assignment.</p><p>That experience stayed with me.</p><p>I realised that there is a dangerous sentence engineers sometimes tell themselves:</p><p><strong>“I understand what they mean.”</strong></p><p>Sometimes we don’t.</p><p>We understand what <em>we think they mean</em>.</p><p>Those are different things.</p><p>Today I would ask much more explicitly:</p><blockquote><em>“When you say this feature, how do you expect the user to interact with it?”</em></blockquote><p>Or:</p><blockquote><em>“Can you show me what the final experience should roughly look like?”</em></blockquote><p>Ten minutes of clarification can save several days of implementation.</p><p>That project taught me:</p><blockquote><strong><em>Do not start by asking, “How should I build this?” Start by asking, “What problem are we actually trying to solve?”</em></strong></blockquote><h3>3. When the timeline is small, ask questions and communicate faster</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tv7cd6dZM1PrY7OGKUTbbg.png" /></figure><p>Earlier, I sometimes thought asking many questions might make me look inexperienced.</p><p>Working under tight deadlines changed that thinking.</p><p>When one of our timelines compressed from months to weeks, I knew that waiting quietly with a doubt could become expensive.</p><p>So my communication style changed.</p><p>I started sending frequent progress updates through Slack.</p><p>If something worked, I updated the team.</p><p>If something was blocked, I mentioned it.</p><p>If I needed clarification from a specific person, I tagged them.</p><p>And when the situation was urgent enough, instead of allowing a question to sit unanswered for hours, I called.</p><p>Not because every problem deserves a call.</p><p>But because when only a few days remain, a six-hour misunderstanding can become a significant percentage of the entire development window.</p><p>I also started doing smaller experiments.</p><p>Instead of spending a long time thinking:</p><p><strong>“Will this approach work?”</strong></p><p>I tried to answer it quickly.</p><p>Run the experiment.</p><p>Check the output.</p><p>Ask the relevant person.</p><p>Adjust.</p><p>Repeat.</p><p>This created a much faster feedback loop.</p><p>For me, it became:</p><p><strong>Question → Experiment → Result → Communicate → Adjust</strong></p><p>rather than:</p><p><strong>Assume → Build for days → Discover the assumption was wrong</strong></p><p>This was one of the most useful behavioural changes I learned.</p><p>Communication is not something separate from engineering.</p><p>Under a deadline, communication is part of engineering.</p><p>A blocker that exists only in your head is invisible to everyone else.</p><p>A blocker communicated early can often be solved.</p><p>So one rule I now try to follow is:</p><blockquote><strong><em>If a mistake or blocker can affect the timeline, communicate it immediately.</em></strong></blockquote><p>Not tomorrow.</p><p>Not after trying another ten things silently.</p><p>Early.</p><h3>4. Know what the expected outcome looks like before doing the hard work</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ds-Pay_fJtPdRxVfDbAa1w.png" /></figure><p>The CLI-versus-UI mistake gave me another lesson.</p><p>It is possible to work extremely hard and still move in the wrong direction.</p><p>That is uncomfortable to admit because we often associate effort with progress.</p><p>But they are not the same.</p><p>Imagine two roads.</p><p>You run ten kilometres on the wrong road.</p><p>Someone else walks two kilometres on the correct road.</p><p>Who is closer to the destination?</p><p>This is exactly why I now care much more about the phrase:</p><p><strong>“What does done look like?”</strong></p><p>Before implementing something, I want to understand the expected output.</p><p>For software, that could mean:</p><ul><li>Is the feature supposed to be a CLI command or a web interface?</li><li>Who is the user?</li><li>What does the user need to see?</li><li>Which workflow is supposed to improve?</li><li>What output should this component produce?</li><li>What would make the senior or client say, “Yes, this solves the problem”?</li></ul><p>This doesn’t mean discussing every font size or every small UI choice before development.</p><p>It means aligning on the destination.</p><p>Because once the destination is clear, engineering becomes much easier.</p><p>You can make dozens of implementation decisions independently while still knowing whether you are travelling in the right direction.</p><p>Without that clarity, even technically excellent work can miss the project.</p><p>One sentence summarises this lesson for me:</p><blockquote><strong><em>Hard work in the wrong direction is still the wrong direction.</em></strong></blockquote><h3>5. Make success measurable so feedback does not depend on opinion</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*khrLgCpAXGEjrCLsJcVc-Q.png" /></figure><p>This lesson became especially important for me because I work in AI/ML.</p><p>AI projects can easily become subjective.</p><p>Someone says:</p><p><strong>“Improve the model.”</strong></p><p>Okay.</p><p>Improve it by how much?</p><p>On which dataset?</p><p>Using which metric?</p><p>What counts as good enough?</p><p>Suppose one person looks at the result and says:</p><p>“This looks much better.”</p><p>Another person says:</p><p>“I don’t think this is good enough.”</p><p>Who is correct?</p><p>Without an agreed measurement, both can be correct from their own perspectives.</p><p>This becomes even more complicated inside a company because not everyone involved in a project has the same technical background.</p><p>An ML engineer may think about:</p><ul><li>evaluation methodology,</li><li>precision,</li><li>recall,</li><li>exact match,</li><li>latency,</li><li>inference cost,</li><li>model size,</li><li>hallucination rate,</li><li>generalisation.</li></ul><p>Someone from the business side may simply want to know:</p><p><strong>“Does it perform better?”</strong></p><p>And that is a completely reasonable question.</p><p>The responsibility is partly on us to convert technical work into something measurable.</p><p>Instead of:</p><p><strong>“Make the model better.”</strong></p><p>I prefer something closer to:</p><p><strong>“The model should achieve at least X on this evaluation metric.”</strong></p><p>For example:</p><blockquote><em>“The target is at least 80% on this agreed evaluation.”</em></blockquote><p>Now the review becomes much clearer.</p><p>Did we achieve it?</p><p><strong>Yes or no.</strong></p><p>If yes, we know the technical requirement was satisfied.</p><p>If no, we know more work is needed.</p><p>Of course, real software projects cannot reduce everything to one number.</p><p>But wherever possible, measurable acceptance criteria remove ambiguity.</p><p>And this changes feedback itself.</p><p>I used to think review happened mainly <strong>after</strong> implementation.</p><p>Now I realise a good review begins <strong>before</strong> implementation.</p><p>If the senior and engineer agree on the measurable outcome at the beginning, a large part of the final review has already been structured.</p><p>You are no longer asking:</p><p><strong>“Do you like what I built?”</strong></p><p>You are asking:</p><p><strong>“Did we achieve what we agreed to achieve?”</strong></p><p>That is a much healthier engineering conversation.</p><h3>The bigger lesson: Software engineering is a clarity problem</h3><p>When I look back at these experiences, the biggest change in my thinking is not about Python, ML models, APIs or system architecture.</p><p>It is about <strong>clarity</strong>.</p><p>Before starting:</p><ul><li><strong>What is the problem?</strong></li><li><strong>What is the timeline?</strong></li><li><strong>What outcome is expected?</strong></li></ul><p>During execution:</p><ul><li><strong>What assumptions should I test quickly?</strong></li><li><strong>What blockers should I communicate immediately?</strong></li></ul><p>After execution:</p><ul><li><strong>Did we achieve the measurable outcome?</strong></li><li><strong>What feedback can improve the next iteration?</strong></li></ul><p>The technical implementation still matters enormously.</p><p>But good implementation cannot rescue a fundamentally misunderstood problem.</p><p>I am still primarily an AI/ML engineer, and I am still learning the broader software engineering side of building production systems.</p><p>That is exactly why these experiences have been valuable.</p><p>They showed me that becoming a better engineer is not only about learning more tools.</p><p>Sometimes it is about asking one better question before opening the editor.</p><p>Sometimes it is about telling your senior that something went wrong immediately rather than trying to hide it until you fix it.</p><p>Sometimes it is about understanding that the deadline has changed and completely changing your approach.</p><p>And sometimes it is about accepting an uncomfortable truth:</p><p><strong>You can build something correctly and still build the wrong thing.</strong></p><h3>The five lessons I am carrying forward</h3><ol><li><strong>Understand the timeline first.</strong><br>A four-month solution and a one-week solution require different thinking.</li><li><strong>Understand the actual problem.</strong><br>Never let your own assumptions silently become product requirements.</li><li><strong>Experiment quickly and communicate early.</strong><br>Especially when the timeline is tight, unanswered questions become project risks.</li><li><strong>Define what “done” looks like.</strong><br>Do not spend days optimising something before confirming that it is the expected outcome.</li><li><strong>Make success measurable.</strong><br>Wherever possible, replace subjective feedback with agreed metrics or clear acceptance criteria.</li></ol><p>I learned these from real work, including mistakes, pressure, misunderstandings and feedback from senior engineers.</p><p>I will probably make many more mistakes as I continue growing.</p><p>But I want them to be <strong>new mistakes</strong>, not repetitions of lessons I have already been fortunate enough to learn.</p><p>And maybe that is one of the most important parts of engineering growth:</p><p><strong>Build the product, review the result, learn from the gap, and make the next iteration better.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b316bbc15af0" width="1" height="1" alt=""><hr><p><a href="https://ai.plainenglish.io/5-software-engineering-lessons-i-learned-the-hard-way-as-an-ai-ml-engineer-b316bbc15af0">5 Software Engineering Lessons I Learned the Hard Way as an AI/ML Engineer</a> was originally published in <a href="https://ai.plainenglish.io/">Artificial Intelligence in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Made My First Contribution to PyTorch: From a “Good First Issue” to Two Merged PRs]]></title>
            <link>https://blog.stackademic.com/how-i-made-my-first-contribution-to-pytorch-from-a-good-first-issue-to-two-merged-prs-fdfa6cf74de8?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/fdfa6cf74de8</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[pytorch]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 01:47:54 GMT</pubDate>
            <atom:updated>2026-09-24T01:47:54.522Z</atom:updated>
            <content:encoded><![CDATA[<p>How I went from finding a “good first issue” to contributing CPython tests to PyTorch Dynamo</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JBh26w8xbO7cqyOL8Xvo9Q.jpeg" /></figure><p>Contributing to a project as large as PyTorch can look intimidating from the outside.</p><p>I had already been working across multiple repositories in my day-to-day engineering work, backend services, databases, application code, and related modules, so I was comfortable with Git and navigating different codebases. But contributing to PyTorch was still different. It is a huge open-source project used by millions of developers and researchers.</p><p>Rather than giving you fake motivation, I want to tell you about my exposure and what I know about it so that you know the reality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*VFs2xTUtQHFS1ljozAwLGA.png" /><figcaption>Exposure</figcaption></figure><p>I decided the best way to start was not by trying to solve a complicated PyTorch bug. I looked for a well-defined <strong>good first issue</strong>.</p><p>That decision led to my first two merged PyTorch contributions.</p><h3>Finding the issue</h3><p>I found PyTorch issue <strong>#196238 — “Port more CPython tests to run under Dynamo.”</strong></p><p>The issue was labeled good first issue, OSS contribution wanted, and module: dynamo. More importantly for someone new to the project, the maintainer had documented almost the entire process: where to get the original CPython test, how to adapt it, how to run it with Dynamo, how to represent expected failures, how to generate the diff, and how to run linting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iMz23rwWpLQ5n81y6Om6wQ.png" /><figcaption>PyTorch issue #<a href="https://github.com/pytorch/pytorch/issues/196238">196238</a></figcaption></figure><p>That taught me something immediately:</p><p><strong>A large repository doesn’t necessarily mean your first contribution needs to be large.</strong></p><p>Sometimes maintainers have already divided a larger project into small, self-contained tasks.The issue contained several CPython modules that needed to be ported. I worked on two of them: test_grammar and test_str.</p><h3>What was I actually doing?</h3><p>PyTorch has a test directory containing modules adapted from <strong>CPython 3.13.5</strong> so that the tests can execute through torch.compile and Dynamo.</p><p>The general process was to take the corresponding CPython test, adapt its unittest.TestCase classes to PyTorch&#39;s CPythonTestCase, run the suite with Dynamo enabled, identify unsupported cases, record expected failures, generate the source diff, and validate everything. (<a href="https://github.com/pytorch/pytorch/issues/196238">GitHub</a>)</p><p>One of the important commands was:</p><pre>PYTORCH_TEST_WITH_DYNAMO=1 \<br>python test/cpython/v3_13/&lt;module&gt;.py -v</pre><p>I didn’t have to invent this workflow myself. The issue explained it and even pointed to existing examples.</p><p>That was extremely helpful.</p><h3>My first PR: test_grammar</h3><p>I started by cloning the repository and working through test_grammar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8BK2YDVxiG7YRw3sCDYS0A.png" /><figcaption>PyTorch bot created a new commit and merged the code, so after merging it closed this PR.</figcaption></figure><p>I used the original CPython test as the base, made the Dynamo-specific adaptations, ran the tests, and recorded cases that were currently unsupported under Dynamo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/1*pXS_T2KDnnwT53w5Q_sFXA.png" /></figure><p>The final PR ran <strong>79 tests</strong>. The normal test run passed all 79, while the Dynamo run completed successfully with 33 skipped cases. The PR also included the generated CPython diff and expected-failure markers. (<a href="https://github.com/pytorch/pytorch/pull/196482">GitHub</a>)</p><p>I also used AI while working on the contribution, particularly for understanding some failure traces and helping me reason through parts of the task. But I did not treat AI output as the result. I reviewed the changes and ran the tests locally — which I also disclosed directly in the PR. (<a href="https://github.com/pytorch/pytorch/pull/196482">GitHub</a>)</p><p>The maintainer reviewed the PR, approved it, and issued:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*4Srgi7oDwyLdZGWChOYr7g.png" /><figcaption>PR Link: <a href="https://github.com/pytorch/pytorch/pull/196482">https://github.com/pytorch/pytorch/pull/196482</a></figcaption></figure><p>Then something happened that confused me as a first-time PyTorch contributor.</p><p>The merge job was cancelled or timed out.</p><p>Initially, seeing a failed merge process made me think perhaps something was wrong with my contribution. But the PyTorch bot itself explained that the merge command could simply be reissued in this situation.</p><p>So I did:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*PnSUJ1X4U_c3Rx-oADD2EQ.png" /></figure><p>again.</p><p>This time it went through.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4iyH8s0DmMY5wM5Ici-HuA.png" /><figcaption>Merged Commit: <a href="https://github.com/pytorch/pytorch/commit/a00a3b5189a09661201138da8ecc749a7bd9ecd1">Link</a></figcaption></figure><p>My test_grammar contribution landed in PyTorch as commit <strong>a00a3b5</strong> on September 10, 2026. GitHub records me as the author and pytorchmergebot as the committer. (<a href="https://github.com/pytorch/pytorch/commit/a00a3b5189a09661201138da8ecc749a7bd9ecd1">GitHub</a>)</p><h3>The second PR taught me more: test_str</h3><p>test_str was more interesting because it didn&#39;t go as smoothly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5_qdaa0MvdeRQIQqsvzCgg.png" /><figcaption>PyTorch bot created a new commit and merged the code, so after merging it closed this PR.</figcaption></figure><p>The CI initially failed, and the maintainer asked me to investigate the Dynamo CPython test. I made another change so the port used the local string_tests helper correctly. Then the maintainer reviewed the PR and requested further changes. (<a href="https://github.com/pytorch/pytorch/pull/196498">GitHub</a>)</p><p>There was also an important difference between what I observed locally and what the maintainer observed in their development environment.</p><p>Some tests I had classified one way were passing for the maintainer. Instead of treating that as a failure of the contribution, we used the review process to correct the classification. I moved failing cases into dynamo_expected_failures and removed markers for cases that actually passed under Dynamo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*h-1Idal6fy9GLXUWp8tJIw.png" /></figure><p>That back-and-forth was probably more valuable to me than having the PR accepted immediately.</p><p>The final test_str Dynamo run contained <strong>135 tests: 50 passing, 11 explicitly skipped, and 74 recorded as expected failures</strong>. (<a href="https://github.com/pytorch/pytorch/pull/196498">GitHub</a>)</p><p>After the changes were reviewed, the maintainer approved the PR and triggered the merge bot. It landed on September 16 as commit <strong>820e83f</strong>. Again, GitHub records me as the author and PyTorch’s merge bot as the committer. (<a href="https://github.com/pytorch/pytorch/pull/196498">GitHub</a>)</p><h3>The biggest thing I learned</h3><p>My biggest learning wasn’t a PyTorch API or a particular Git command.</p><p>It was <strong>communication</strong>.</p><p>If you are new to a project, it is completely okay to say so.</p><p>You can tell a maintainer:</p><blockquote><em>I’m new to this project. Please let me know if I’ve misunderstood something, and I’m happy to make the changes.</em></blockquote><p>You don’t need to pretend that you already understand everything.</p><p>In my case, maintainer feedback helped me correct the contribution and understand the project’s expectations better. A review requesting changes wasn’t a rejection — it was part of contributing.</p><p>I also learned not to panic when CI fails, when a bot closes a PR, or when your local environment produces slightly different results. Read the bot message. Read the maintainer’s comment. Check the tests. Make the change. Ask when you’re unsure.</p><p>Both of my PR pages now show as <strong>closed</strong>, but they weren’t rejected. PyTorch’s merge infrastructure landed them into main, and the corresponding commits preserve my authorship. (<a href="https://github.com/pytorch/pytorch/pull/196482">GitHub</a>)</p><h3>If you’re thinking about your first contribution</h3><p>Don’t start by asking yourself:</p><p><strong>“Am I good enough to contribute to PyTorch?”</strong></p><p>A better question is:</p><p><strong>“Can I understand one well-scoped issue, reproduce what the maintainer describes, make a small change, test it, and respond to review?”</strong></p><p>That’s how I started.</p><p>Not by understanding the entire PyTorch codebase.</p><p>Just one issue, then one module, then one PR.</p><p>And then another one.</p><ul><li><a href="https://github.com/pytorch/pytorch/commits/main/?author=Rudra-G-23">https://github.com/pytorch/pytorch/commits/main/?author=Rudra-G-23</a></li><li>Connect with me: <a href="https://linktr.ee/rudra_prasad_bhuyan?utm_source=linktree_profile_share&amp;ltsid=fdbf95a8-f577-45b4-b787-037aeac05eb2">https://linktr.ee/rudra_prasad_bhuyan</a></li></ul><h3>Before you go</h3><ul><li>Please take a moment to like the post and follow the writer!</li><li>Did you know that over 400,000 developers share what they’re building, learning, and discovering across our platforms every month? Learn how you can contribute <a href="https://plainenglish.io/write-for-us"><strong>here</strong></a><strong>.</strong></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fdfa6cf74de8" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/how-i-made-my-first-contribution-to-pytorch-from-a-good-first-issue-to-two-merged-prs-fdfa6cf74de8">How I Made My First Contribution to PyTorch: From a “Good First Issue” to Two Merged PRs</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Customer Support Agent with Jev: From a Chatbot to a Decision-Driven AI System]]></title>
            <link>https://blog.stackademic.com/building-a-customer-support-agent-with-jev-from-a-chatbot-to-a-decision-driven-ai-system-cfebe2704ed7?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfebe2704ed7</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[customer-support]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[aritificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 01:39:21 GMT</pubDate>
            <atom:updated>2026-09-24T01:39:21.600Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MmocPFHcLA5Pltaomk7xtQ.png" /><figcaption>Made by Autor</figcaption></figure><p>While exploring <strong>Jev from TypeSafe AI</strong>, I wanted to understand where a decision model like this actually fits inside a real AI application.</p><p>A customer-support agent is a useful example because a support message rarely contains only one signal.</p><p>A customer might say:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*NkpaXAnrV3vRWK8bZRyHdw.png" /><figcaption>Customer Input</figcaption></figure><p>A system looking at this message may need to determine several things at once:</p><ul><li>What is the main intent?</li><li>Is the customer asking for a refund?</li><li>How frustrated are they?</li><li>How urgent is the problem?</li><li>Is there a risk of churn?</li><li>Should this be handled automatically?</li><li>Should a billing agent, retention agent, or human handle it?</li></ul><p>A traditional LLM agent can reason about all of these questions. But the interesting idea behind Jev is to separate <strong>decision-making</strong> from <strong>language generation</strong>.</p><p>Jev is TypeSafe’s System One model. Instead of primarily producing prose, it evaluates typed questions against some state and returns structured values that application code can directly use. Its three main primitives are <strong>Choice, Score, and Noul</strong>. (<a href="https://docs.typesafe.ai/">TypeSafe AI</a>)</p><p>That leads to the architecture in the diagram.</p><h3>1. Customer Input: Where Everything Starts</h3><p>The first component is simple:</p><p><strong>Customer → Input channel → Backend</strong></p><p>The message might arrive through: a chat widget, email, a mobile application, WhatsApp, support portal, or even a voice system after speech-to-text.</p><p>At this point, we have mostly unstructured text.</p><p>For example:</p><blockquote><em>“I was charged twice for my subscription and haven’t received a response. I’m really frustrated and might cancel if this isn’t fixed soon.”</em></blockquote><p>An ordinary chatbot could immediately send this message to an LLM and ask:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/1*rnW8p-TAl9kehtl7kJ6eTA.png" /></figure><p>That can work, but now one model is being asked to perform several jobs simultaneously: classify the problem, judge severity, infer customer sentiment, decide whether tools should be called, decide whether escalation is necessary, and finally generate the response.</p><p>For a simple demo, that may be enough.</p><p>For a production system, it can be useful to separate those responsibilities.</p><h3>2. Build Context: Give the Decision Layer the Right State</h3><p>The customer message alone usually isn’t enough.</p><p>Before making a decision, the backend can construct a richer <strong>state</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*Suckco4Eth37JRykIayEIQ.png" /></figure><p>Imagine the same message with additional information:</p><pre>Customer:<br>    account_age: 4 years<br>    plan: enterprise<br>    lifetime_value: high<br>Subscription:<br>    status: active<br>    renewal_date: Sep 20<br>Payments:<br>    Sep 20: ₹2,499<br>    Sep 20: ₹2,499<br>Recent tickets:<br>    billing ticket opened 2 days ago<br>    no response yet<br>Message:<br>    &quot;I was charged twice...&quot;</pre><p>Now the AI is no longer judging one sentence in isolation.</p><p>It has the <strong>state of the situation</strong>.</p><p>This part remains normal application engineering. Your backend might collect the information from PostgreSQL, Stripe, CRM systems, ticket databases, internal APIs, or other services.</p><p>Jev does not replace those systems.</p><p>It evaluates the state you give it.</p><h3>3. The Jev Decision Layer</h3><p>This is the central part of the architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/479/1*rHU-T4K22SPOZtlI50d08w.png" /></figure><p>Instead of asking:</p><blockquote><em>“What should we do with this customer?”</em></blockquote><p>we can break that large question into smaller, atomic decisions.</p><p>For example:</p><pre>What is the primary intent?<br>How angry is the customer?<br>How urgent is this?<br>Is the customer requesting a refund?<br>Is there a meaningful churn risk?<br>Is this a high-value customer?</pre><p>TypeSafe specifically recommends this kind of decomposition: ask focused questions independently and combine the answers using application logic when the final decision depends on several factors. (<a href="https://docs.typesafe.ai/">TypeSafe AI</a>)</p><p>Jev provides three primitives for doing this.</p><h3>4. Choice: Pick One Option</h3><p>The first primitive is <strong>Choice</strong>.</p><p>Use Choice when one answer needs to be selected from a known set.</p><p>For our support system:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/871/1*lE-Iqqwr6y3UsVtEob49Tw.png" /></figure><p>So the most likely answer is: <strong><em>billing_issue</em></strong></p><p>This distinction becomes important later.</p><p>Instead of:</p><pre>intent = &quot;billing&quot;</pre><p>we effectively know:</p><pre>intent = &quot;billing&quot;<br>confidence = ...<br>probability_distribution = {...}</pre><p>Now the backend can decide how much it trusts that classification.</p><h3>5. Score: Measure Something on a Spectrum</h3><p>Some questions don’t have categorical answers.</p><p>Consider frustration.</p><p>We don’t necessarily want:</p><pre>angry = true</pre><p>We may instead want something more like:</p><pre>How frustrated is this customer?</pre><p>with levels representing something like:</p><pre>0 → calm<br>1 → mildly frustrated<br>2 → frustrated<br>3 → very frustrated<br>4 → extremely frustrated</pre><p>That is where <strong>Score</strong> fits.</p><p>A Score judges something against ordered descriptive levels. Jev can return a position on that scale, along with probabilities for the levels and a confidence value. (<a href="https://docs.typesafe.ai/primitives/score">TypeSafe AI</a>)</p><p>We might evaluate:</p><pre>anger<br>urgency<br>problem severity<br>churn risk<br>customer satisfaction</pre><p>separately.</p><p>That is much more useful than hiding everything inside one vague prompt such as:</p><blockquote><em>“How important is this ticket?”</em></blockquote><h3>6. Noul: Ask a Yes/No Question</h3><p>The third primitive is <strong>Noul</strong>.</p><p>A Noul represents the probability that a yes/no statement is true.</p><p>For example:</p><pre>&quot;Is the customer requesting a refund?&quot;</pre><p>The result could be:</p><pre>0.92</pre><p>A value near 1 means a strong yes, a value near 0 means a strong no, and values around the middle indicate ambiguity. (<a href="https://docs.typesafe.ai/primitives/noul">TypeSafe AI</a>)</p><p>For customer support, Nouls could ask:</p><pre>Is the customer requesting a refund?<br>Is the customer threatening to cancel?<br>Is human escalation requested?<br>Is this a repeat complaint?<br>Is the customer a high-value customer?<br>Does the message contain sensitive information?</pre><p>Then our normal Python or TypeScript code decides what those values mean operationally.</p><p>For example:</p><pre>if refund_requested &gt; 0.90:<br>    require_refund_workflow()</pre><p>The threshold belongs to the application.</p><p>That is an important architectural idea.</p><p><strong>The model provides the judgment. The software controls the policy.</strong></p><h3>7. One State, Multiple Decisions</h3><p>Now the architecture becomes more interesting.</p><p>For the same customer message, we might ask Jev all of these questions:</p><pre>Choice:<br>    What is the intent?<br>Noul:<br>    Is a refund requested?<br>Noul:<br>    Is cancellation being considered?<br>Score:<br>    How frustrated is the customer?<br>Score:<br>    How urgent is the problem?<br>Noul:<br>    Is this a high-value customer?</pre><p>These questions can be evaluated together. TypeSafe’s documentation describes questions in one request as being evaluated independently and in parallel against the same state. (<a href="https://docs.typesafe.ai/">TypeSafe AI</a>)</p><p>So instead of building a long sequential chain:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*ws3rFZRRNpO899YmS3XbyQ.png" /></figure><p>and then use the results in code.</p><p>This leads directly to the patterns shown in the second half of the diagram.</p><h3>8. Pattern One: Intent Routing</h3><p>The first pattern is <strong>Intent Routing</strong>.</p><p>Suppose Choice returns:</p><pre>billing_issue       0.82<br>technical_issue     0.08<br>account_management  0.05<br>product_question    0.03<br>other               0.02</pre><p>The application can now route the ticket:</p><pre>billing_issue<br>      ↓<br>Billing Support</pre><p>Another ticket might go:</p><pre>technical_issue<br>      ↓<br>Technical Support Agent</pre><p>and another:</p><pre>account_management<br>      ↓<br>Account Service</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/422/1*h7D3CCnxdyIoBTyQzbus9w.png" /></figure><p>This is also where the difference from a generic LLM architecture becomes clearer.</p><p>A common architecture is:</p><pre>Customer<br>   ↓<br>Large LLM<br>   ↓<br>&quot;Figure everything out&quot;<br>   ↓<br>Tools</pre><p>With a decision layer, we can instead build:</p><pre>Customer<br>   ↓<br>Jev<br>   ↓<br>Determine intent<br>   ↓<br>Backend router<br>   ├── Billing workflow<br>   ├── Technical workflow<br>   ├── Specialist LLM<br>   ├── Database lookup<br>   └── Human</pre><p>Not every ticket necessarily needs an expensive generative model.</p><p>A password-status request might only require deterministic code and a database lookup.</p><p>A complicated billing dispute might require a specialized LLM with tools.</p><p>A highly ambiguous complaint might go directly to a person.</p><h3>9. Pattern Two: Confidence-Gated Routing</h3><p>Classification alone isn’t enough.</p><p>Suppose the model says:</p><pre>intent = billing_issue</pre><p>The next question should be:</p><p><strong>How certain are we?</strong></p><p>This is where confidence-gated routing enters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*B9yQceZE0qkMIQ8TPJ1iJw.png" /></figure><p>And thresholds do not have to be universal.</p><p>For example:</p><pre>FAQ classification<br>threshold = 0.60<br><br>billing routing<br>threshold = 0.75<br><br>automatic refund<br>threshold = 0.95</pre><p>The consequences of being wrong are different.</p><p>That policy remains visible in application code rather than being buried inside a long system prompt.</p><h3>10. Pattern Three: Speculative Fan-Out</h3><p>Now consider our example again:</p><blockquote><em>“I was charged twice for my subscription and haven’t received a response. I’m really frustrated and might cancel if this isn’t fixed soon.”</em></blockquote><p>There may not actually be only one relevant intent.</p><p>We could find:</p><pre>billing_issue        0.60<br>refund_request       0.25<br>subscription_cancel  0.10<br>payment_method       0.05</pre><p>This ticket potentially involves:</p><pre>Billing<br>Refund<br>Retention</pre><p>Instead of waiting for one classification and then making additional AI calls, <strong>speculative fan-out</strong> asks useful downstream questions upfront.</p><p>TypeSafe’s pattern describes sending multiple questions together — even ones that may ultimately prove irrelevant — and then letting normal code ignore the answers it does not need. (<a href="https://docs.typesafe.ai/patterns/fan-out">TypeSafe AI</a>)</p><p>Conceptually:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/527/1*5Y9m8l2PG-qUKI-GNASbMw.png" /></figure><p>Suppose the customer never requested cancellation.</p><p>The retention-related result can simply be ignored.</p><p>But if cancellation risk turns out to matter, the result is already available.</p><p>This becomes especially useful in workflows with many possible branches.</p><h3>11. Pattern Four: Composite Scoring</h3><p>Sometimes no single signal should decide what happens.</p><p>Imagine we have:</p><pre>anger              = 0.91<br>urgency            = 0.45<br>churn risk         = 0.78<br>high-value customer = 0.85</pre><p>We might define an escalation score ourselves:</p><pre>priority =<br>    0.4 × anger<br>  + 0.3 × urgency<br>  + 0.2 × churn_risk<br>  + 0.1 × customer_value</pre><p>Giving approximately:</p><pre>priority = 0.74</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/434/1*_5_LKcu3U_qrN7qxvOnYYA.png" /></figure><p>Now the business can decide:</p><pre>0.00–0.40 → normal queue<br>0.40–0.70 → priority queue<br>0.70–1.00 → urgent escalation</pre><p>The interesting part is that <strong>Jev isn’t deciding the business formula</strong>.</p><p>Your application does.</p><p>TypeSafe calls this pattern <strong>Composite Scoring</strong>: evaluate independent dimensions and combine them using weights controlled by code. (<a href="https://docs.typesafe.ai/patterns/composite-scoring">TypeSafe AI</a>)</p><p>If the business later decides churn matters more, we don’t necessarily need to rewrite one giant prompt.</p><p>We can change:</p><pre>priority = (<br>    0.30 * anger<br>    + 0.20 * urgency<br>    + 0.40 * churn_risk<br>    + 0.10 * customer_value<br>)</pre><p>That makes the final decision logic much easier to inspect.</p><h3>12. Take Action: This Is Where the LLM Can Return</h3><p>Jev does not mean removing LLMs from the architecture.</p><p>It can actually make their role more specific.</p><p>Imagine Jev determines:</p><pre>intent = billing_issue<br>confidence = high<br>refund_requested = high<br>frustration = high<br>cancellation_risk = high</pre><p>Now we know which generative system should be called.</p><p>For example:</p><pre>Jev<br> ↓<br>Billing specialist LLM<br> ↓<br>Tools<br> ├── get_invoice()<br> ├── inspect_payment()<br> ├── issue_refund()<br> └── update_ticket()</pre><p>The LLM can concentrate on what generative models are good at:</p><ul><li>understanding detailed instructions,</li><li>working with tool results,</li><li>reasoning through complicated cases,</li><li>generating a natural customer response,</li><li>summarizing the investigation.</li></ul><p>Jev handles the smaller structured judgments that determine <strong>which path should run</strong>.</p><p>So this isn’t really: Jev vs LLM</p><p>It is more useful to think of it as:</p><ul><li>Jev → decide</li><li>Code → control</li><li>LLM → reason/generate when required</li><li>Tools → perform actions</li></ul><h3>13. What a Normal LLM Architecture Might Look Like</h3><p>Without this separation, we might build:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*U2jotO7sIiJvHdGOXkEi7A.png" /></figure><p>Modern LLM systems can absolutely produce structured outputs, so this architecture is possible.</p><p>The difference is architectural.</p><p>Jev is specifically built around structured decisions: <strong>Choice, Score, and Noul</strong> return values designed to be consumed by software rather than prose designed primarily for a human reader. (<a href="https://docs.typesafe.ai/">TypeSafe AI</a>)</p><p>That allows us to move from one large fuzzy instruction toward several explicit decisions.</p><p>For example:</p><pre>Instead of:<br>&quot;Should this ticket be escalated?&quot;<br><br>we have:<br>anger = ...<br>urgency = ...<br>churn_risk = ...<br>customer_value = ...<br>intent = ...<br>confidence = ...<br><br>and then:<br>if priority &gt; 0.70:<br>    escalate()</pre><p>That separation is what I find interesting.</p><h3>14. Learn and Monitor</h3><p>The final component in the diagram is:</p><pre>Take Action<br>     ↓<br>Learn &amp; Monitor<br>     ↓<br>feedback into the system</pre><p>This shouldn’t be interpreted as Jev automatically learning from every support ticket.</p><p>The application should capture what happened after each decision.</p><p>For example:</p><pre>Predicted intent: billing<br>Actual team: billing<br>Predicted refund request: 0.92<br><br><br>Human decision: refund requested<br>Predicted high priority: 0.74<br>Actual escalation: yes<br><br><br>Customer outcome:<br>issue resolved<br>subscription retained</pre><p>Over time, we can evaluate:</p><ul><li>which classifications are wrong,</li><li>which confidence thresholds are too aggressive,</li><li>which questions are ambiguous,</li><li>which routes frequently need human correction,</li><li>whether our composite weights make sense,</li><li>and where automation should be reduced or increased.</li></ul><p>Then we improve the <strong>system</strong>.</p><p>or we rewrite one Choice criterion because billing and subscription-management requests are being confused.</p><p>This closes the loop.</p><h3>Putting the Whole Architecture Together</h3><p>The complete system becomes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*aBRLkXjTit3fFRGOUlMckA.png" /></figure><p>That is the main idea behind the diagram.</p><p>The customer still experiences a normal support agent.</p><p>But behind that simple interface, the system has separated <strong>understanding, judgment, policy, generation, and execution</strong>.</p><h3>The Main Idea I Took Away From Jev</h3><p>What interested me most about Jev wasn’t simply getting another model response.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/859/1*7cwCuV7B4XKkHnOVlimjhw.png" /></figure><p>Jev does not need to replace the LLM.</p><p>It can become a <strong>decision layer around the LLM</strong>, helping software determine when an LLM is needed, which LLM or workflow should receive the request, which tools should be exposed, when automation is safe, and when a human should take over.</p><p>For a customer-support agent, that turns the architecture from simply <strong>“chat with an LLM”</strong> into something closer to a controlled decision system.</p><h3>Before you go</h3><ul><li>Please take a moment to like the post and follow the writer!</li><li>Did you know that over 400,000 developers share what they’re building, learning, and discovering across our platforms every month? Learn how you can contribute <a href="https://plainenglish.io/write-for-us"><strong>here</strong></a><strong>.</strong></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfebe2704ed7" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/building-a-customer-support-agent-with-jev-from-a-chatbot-to-a-decision-driven-ai-system-cfebe2704ed7">Building a Customer Support Agent with Jev: From a Chatbot to a Decision-Driven AI System</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS End-to-End MLOp’s Architects]]></title>
            <link>https://blog.stackademic.com/aws-end-to-end-mlops-architects-49b2f2bd8efe?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/49b2f2bd8efe</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Fri, 14 Aug 2026 07:03:59 GMT</pubDate>
            <atom:updated>2026-08-14T07:03:59.470Z</atom:updated>
            <content:encoded><![CDATA[<p>Designing an Enterprise-Grade MLOps Platform on AWS: A Multi-Account Architecture Walkthrough</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6GShWyFiLZw4EBRdVvoj4g.png" /></figure><h3>Why do we need this kind of complex architecture?</h3><p>Most teams start their machine learning journey in a single AWS account. A data scientist spins up a SageMaker notebook, pulls some data from S3, trains a model, and deploys it to an endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ME7Vi-aDMju4oBO25-Kp_A.png" /></figure><p>It works — until it doesn’t. As soon as more than one team, more than one model, or more than one environment enters the picture, that single-account setup starts to crack under its own weight. Permissions get messy, cost attribution becomes guesswork, and a bad deployment in “test” cane quietly take down something in “prod” because everything shares the same blast radius.</p><h3>Problem we solve Today?</h3><p>The architecture I want to walk through today is the answer large ML organizations converge on once they outgrow that single-account world: a <strong>multi-account MLOps platform</strong>, where every function — data, development, artifacts, CI/CD, staging, and operations — lives in its own AWS account, each with a clear job and a clear boundary. This isn’t a toy reference architecture. It’s the kind of design you’d actually defend in an architecture review board at a bank, an insurer, or any regulated enterprise running ML at scale.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*Ph2sqvC635MTwCudAoXsOA.png" /><figcaption>Image: <a href="https://www.webiny.com/docs/5.x/core-development-concepts/ci-cd/introduction">source</a></figcaption></figure><p>In this article, we answer these three questions</p><ul><li>What services live there</li><li>Why those specific services were chosen</li><li>What’s actually flowing in and out along the arrows connecting them.</li></ul><h3>Why Split Everything Into Separate AWS Accounts?</h3><p>Before touching a single service, it’s worth answering the question a junior engineer always asks first: why not just use IAM roles and VPCs inside one account?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/1*DJZfRcYh_VydiFWWpBnRxQ.png" /></figure><p>Because accounts are the strongest isolation boundary AWS gives you. IAM policies can be misconfigured. A security group can have an overly broad rule. But an AWS account boundary is a hard wall — by default, nothing in Account A can touch a resource in Account B unless you explicitly allow it through a role assumption, a resource policy, or a service like AWS RAM.</p><h4>Benefits?</h4><p>For ML platforms specifically, this buys you three things that matter a lot once you’re operating at scale:</p><ul><li>Blast-radius containment (a bug in staging can’t reach production), clean cost attribution per team or per environment.</li><li>The ability to apply different compliance controls to different stages of the ML lifecycle.</li><li>This is exactly why AWS’s own Well-Architected guidance for multi-account ML platforms pushes toward this pattern, and it’s what you’re looking at in this diagram.</li></ul><p>With that context, let’s go through the accounts.</p><p><a href="https://github.com/Rudra-G-23/system-design">GitHub - Rudra-G-23/system-design: My notes on System Design from the perspective of an AI engineer.</a></p><h3>1. Data Account — The Single Source of Truth</h3><p>Every ML platform has to start somewhere, and it starts with data. The Data Account exists so that all of an organization’s raw and curated data lives in one governed place, completely separate from where models are built or served. This separation matters because data governance, retention policies, and access auditing are usually owned by a different team than the one training models — keeping data in its own account lets that team enforce controls without being in anyone else’s way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NzA39HkXsMq9klq57JKHiA.png" /></figure><p>Inside this account, the diagram groups services into two logical buckets.</p><p><strong>Storage and Databases</strong> is where the raw material lives:</p><ul><li><strong>Amazon S3</strong> — the default landing zone for almost everything: raw files, structured exports, model training datasets. It’s cheap, durable, and everything else in the diagram eventually reads from or writes to it.</li><li><strong>Amazon DynamoDB</strong> — a low-latency NoSQL store, typically used here for things like feature lookups or metadata that needs millisecond access rather than a batch query.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*jiq3oPZpJH1Lga6VTKYrdg.png" /></figure><ul><li><strong>Amazon EFS</strong> — a shared, POSIX-compliant file system. This shows up when multiple training jobs or notebook instances need to read and write the same files concurrently, which S3’s object model doesn’t handle as naturally.</li><li><strong>Amazon RDS</strong> — for relational data that still lives in traditional tables: transactional records, reference data, anything with strong relational integrity requirements.</li></ul><p><strong>Analytics and Big Data</strong> is where that raw data gets refined:</p><ul><li><strong>Amazon EMR</strong> — for large-scale distributed processing (Spark, Hadoop) when datasets are too big to process on a single machine.</li><li><strong>Amazon Redshift</strong> — the data warehouse, used when teams need fast SQL analytics over structured, aggregated data.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/707/1*E56ZURjeLGxIxUij1UsUlQ.png" /></figure><ul><li><strong>Amazon Glue</strong> — the catalog and ETL layer. Glue crawls the data sitting in S3 and other stores, infers schema, and keeps a searchable catalog so downstream consumers know what data exists and where.</li><li><strong>Lake Formation</strong> (“Amazon Lake” in the diagram) — sits on top of S3 and Glue to enforce fine-grained, column- and row-level access control on the data lake, which is critical once multiple teams are pulling from the same lake with different permission levels.</li></ul><p><strong>The arrow out of this account</strong> flows down into the Development Account. What’s moving across that arrow isn’t the raw data itself — it’s <em>access</em> to curated, governed data that data scientists are permitted to query and pull from. This is the handoff point between “data that exists” and “data that’s being used to build something.”</p><h3>2. Development Account — Where Data Scientists Actually Work</h3><p>This is the sandbox. The Development Account is scoped specifically for experimentation, and isolating it from data, artifacts, and production means a data scientist can break things here without any risk of that breakage propagating anywhere else.</p><p>The centerpiece is <strong>Amazon SageMaker Studio</strong>, the IDE for the entire ML workflow — notebooks, experiment tracking, debugging, and model building all in one interface. The two notebook instances shown represent parallel workstreams: different data scientists, or the same person working on different experiments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M6tO1_IGspb16EA76rDoUA.png" /></figure><p>From Studio, two things happen:</p><ul><li><strong>AWS CodeCommit</strong> — every notebook, training script, and pipeline definition that a data scientist writes gets version-controlled here. This is the same discipline you’d apply to application code, applied to ML code — because untracked notebooks are one of the biggest sources of “it worked on my machine” failures in ML teams.</li><li><strong>Amazon S3</strong> — used here to persist outputs like processed features or intermediate artifacts specific to this environment.</li></ul><p>There’s also a labeled arrow feeding “Feature Store Data” down into the Operations Account. This is SageMaker Feature Store in action — features engineered during development get registered centrally so that the exact same feature definitions used in training are reused during inference later, avoiding the classic training-serving skew problem where a feature is computed one way offline and a slightly different way online.</p><p><strong>Input to this account:</strong> governed data access from the Data Account. <strong>Output:</strong> version-controlled code (via CodeCommit) and reusable features (via the Feature Store path) — nothing here goes straight to production.</p><h3>3. Artifact Account — The Vault for Everything That Gets Deployed</h3><p>Once code exists, it needs to become something deployable, and that something needs a home that’s separate from where it was written and separate from where it runs. That’s the Artifact Account’s entire purpose: a controlled, auditable store for build outputs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*Bg_7m_6WCRb-b9-nJpAGng.png" /></figure><ul><li><strong>AWS ECR (Elastic Container Registry)</strong> — stores the Docker container images that package up training and inference code. Almost everything SageMaker runs — training jobs, endpoints, processing jobs — runs inside a container, so ECR is the backbone of reproducibility here. The same image that was tested is the exact image that gets deployed, with no “works differently in prod” surprises.</li><li><strong>Amazon SageMaker Model Monitor</strong> — appears here to capture baseline statistics and data-quality constraints tied to a given model version at the point it’s registered, before it ever sees production traffic.</li><li><strong>Amazon S3</strong> — stores model artifacts themselves (the trained model files, evaluation reports, metadata).</li><li><strong>Amazon EventBridge</strong> — the event bus that reacts when a new artifact lands. Rather than something manually kicking off the next step, EventBridge fires automatically when, say, a new container image is pushed, and pushes that event forward.</li></ul><p><strong>The arrows here matter a lot.</strong> ECR pushes images out toward CI/CD (specifically toward CodeBuild), while EventBridge’s output feeds into the CI/CD Account’s CodePipeline. In other words: this account doesn’t build anything and doesn’t deploy anything — it just holds artifacts and announces when new ones are ready. That single responsibility is deliberate; it’s what makes rollback and audit trivial later, because you always know exactly what artifact was live at any point in time.</p><h3>4. CI/CD Account — The Automation Engine</h3><p>This account owns exactly two things, and does them well: <strong>AWS CodeBuild</strong> and <strong>AWS CodePipeline</strong>.</p><p>CodeBuild compiles, tests, and packages — it’s what actually runs the build steps triggered by a new artifact or code change. CodePipeline is the orchestrator sitting above it, defining the sequence of stages a change has to pass through (build, test, deploy) and gating progression between them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/511/1*GbcEDWhiWiURxKxX09dr2g.png" /></figure><p>Keeping CI/CD in its own account, separate from where artifacts are stored and separate from where they eventually run, means the pipeline’s permissions can be scoped extremely tightly: it can read from the Artifact Account and it can deploy into Staging accounts, and that’s essentially it. If this account were ever compromised, the attacker’s reach is bounded by that narrow permission set — they can’t reach into the Data Account, for instance.</p><p><strong>Input:</strong> the EventBridge signal and ECR image from the Artifact Account. <strong>Output:</strong> a deployment triggered into the Staging accounts, shown by the arrow curving down and to the left in the diagram.</p><h3>5. Staging Accounts — Two Environments, One Pattern</h3><p>The diagram shows two nearly identical staging blocks, and that’s intentional — one represents an internal QA/testing environment (accessed by a <strong>Tester</strong>) and the other represents a pre-production or canary environment used by a broader group of <strong>Users</strong>. Same infrastructure pattern, different audiences and different risk tolerance.</p><p>Both are provisioned using <strong>AWS CloudFormation StackSet</strong>, which deserves a moment of attention: a StackSet lets you define infrastructure once and roll it out consistently across accounts. This is exactly why staging and any later production account end up with identical infrastructure — the StackSet guarantees it, removing “staging doesn’t match prod” as a source of failed deployments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*gMf4xs6_UzX507vHR5Gp1A.png" /></figure><p>Inside each stack:</p><ul><li><strong>Auto Scaling Group</strong> — ensures the compute layer serving the model scales with demand and self-heals if an instance fails.</li><li><strong>Amazon SageMaker Endpoint</strong> — the actual hosted model, serving real-time inference requests.</li><li><strong>AWS Lambda</strong> — typically handles lightweight request preprocessing/postprocessing in front of the endpoint, or orchestrates calls to it.</li><li><strong>Amazon API Gateway</strong> — the front door. Testers and users don’t call the SageMaker endpoint directly; they hit an API Gateway endpoint, which gives you throttling, auth, and a stable contract independent of what’s running behind it.</li><li><strong>Amazon S3 (Data Capture)</strong> — SageMaker’s data capture feature logs every inference request and response here. This isn’t optional in a mature setup — without captured inference data, you have no way to later evaluate whether the model is drifting from what it saw in training.</li><li><strong>Data Replication</strong> to a second S3 bucket — a durability and downstream-analysis safeguard, making captured data available for monitoring jobs without those jobs needing access to the primary bucket.</li></ul><p><strong>Input:</strong> deployment package from CI/CD. <strong>Output:</strong> live inference responses to testers/users, and — critically — a continuous stream of captured request data flowing onward into the Operations Account. That data capture arrow is what connects “the model is live” to “the model is being watched.”</p><h3>6. Operations Account — Where the Loop Closes</h3><p>This is the account that separates a real MLOps platform from a one-time model deployment. Everything up to this point has been linear: data flows down, gets built, gets deployed. The Operations Account is where the architecture becomes a genuine feedback loop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hmQJkFv0Ctm3vZjwvC6RMA.png" /></figure><p>Captured inference data (from Staging) and baseline data land in <strong>Amazon S3</strong> buckets here. From there:</p><ul><li><strong>Amazon SageMaker Model Monitor</strong> compares live inference data against the training baseline, watching for statistical drift in the input data.</li><li><strong>Amazon SageMaker Clarify</strong> checks specifically for bias — whether the model’s predictions are behaving unfairly across sensitive attributes, which matters enormously for anything customer-facing or regulated.</li><li>When either tool detects a problem, it emits a <strong>“Bias or Other kind of drift”</strong> signal, which flows into <strong>Amazon EventBridge</strong>.</li></ul><p>EventBridge then triggers <strong>Amazon SageMaker Pipelines</strong> — shown in the diagram with its own internal tools: a search/inspection step, <strong>AWS Lambda</strong> for lightweight orchestration logic, and <strong>Amazon EMR</strong> for any heavy data reprocessing the retraining job needs.</p><p>Here’s the loop, stated plainly: drift or bias is detected → an automated pipeline is triggered → that pipeline reprocesses data and retrains the model → the new model artifact eventually flows back up toward the Artifact Account, restarting the build-deploy cycle for a corrected model. Nobody has to notice a support ticket about a model behaving strangely three weeks after the fact. The monitoring is watching continuously, and the retraining trigger is automatic.</p><p>This is, honestly, the part of the architecture that separates a serious ML platform from a demo. Training a model once is a project. Watching it, catching when it degrades, and automatically correcting course is a <em>platform</em>.</p><h3>Tying the Whole Thing Together</h3><p>Read as one continuous flow, the architecture tells a coherent story:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*WXRaQffsjoZBqVI-MEPK7w.png" /></figure><p><strong>Data</strong> is governed and curated in one account → <strong>Development</strong> consumes it to build and version models → <strong>Artifacts</strong> stores what gets built, immutably → <strong>CI/CD</strong> automates the path from artifact to deployment → <strong>Staging</strong> serves the model and captures how it behaves in the real world → <strong>Operations</strong> watches that behavior, and when something drifts, it closes the loop by kicking off retraining — which flows all the way back to the top.</p><p>Nothing in this design is accidental. Every account boundary maps to a real organizational or security concern, and every arrow represents a deliberate, auditable handoff rather than an implicit dependency. That’s really the hallmark of enterprise architecture versus a quick prototype — not more services, but every service earning its place, and every connection being something you could explain, defend, and reproduce on demand.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6GShWyFiLZw4EBRdVvoj4g.png" /></figure><p>If you’re building an ML platform and everything currently lives in one account, this is the direction to grow toward — not all at once, but one boundary at a time, starting with the one that matters most for your organization: usually data, or usually production isolation. Either way, the destination looks a lot like the diagram above.</p><ul><li>Tool used: Drawio, Excalidraw Whithboard</li><li>Source Code: <a href="https://github.com/Rudra-G-23/system-design">https://github.com/Rudra-G-23/system-design</a></li><li>Video: <a href="https://youtu.be/Np61NA4qVD4?si=fkjCIDeD1exn1AB2">https://youtu.be/Np61NA4qVD4?si=fkjCIDeD1exn1AB2</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49b2f2bd8efe" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/aws-end-to-end-mlops-architects-49b2f2bd8efe">AWS End-to-End MLOp’s Architects</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tracing an E-Commerce Order Processing Pipeline with Traccia]]></title>
            <link>https://medium.com/@rudraprasadbhuyan999/tracing-an-e-commerce-order-processing-pipeline-with-traccia-38c7dca3d911?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/38c7dca3d911</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[traccia]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 04:52:13 GMT</pubDate>
            <atom:updated>2026-06-23T02:52:37.977Z</atom:updated>
            <content:encoded><![CDATA[<p>As AI and distributed applications become more complex, understanding what happens inside your application becomes increasingly important. A simple request may trigger multiple function calls, external APIs, database queries, and business logic.</p><p>This is where observability and tracing become valuable.</p><p>In this article, we’ll build a small e-commerce order processing pipeline and see how to trace every step using Traccia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VNWrdkmiM13DzvIqD2grTA.jpeg" /><figcaption>Image Code <a href="https://gist.github.com/Rudra-G-23/7e3a68627fa3a2c5734d2c9101242856">Link</a></figcaption></figure><h3>The Pipeline</h3><p>Our order processing system follows this flow:</p><pre>Create Order<br>      │<br>      ▼<br>Validate Order<br>      │<br>      ▼<br>Check Inventory<br>      │<br>      ▼<br>Calculate Price<br>      │<br>      ▼<br>Process Payment<br>      │<br>      ▼<br>Return Order Details</pre><p>You can also include a sequence flow diagram here in Medium to visualize the complete execution path.</p><h3>Why Trace This Workflow?</h3><p>Imagine a customer reports:</p><ul><li>Payment took too long.</li><li>Inventory information was incorrect.</li><li>Order creation failed.</li></ul><p>Without tracing, debugging becomes difficult because you don’t know:</p><ul><li>Which function failed</li><li>How long each step took</li><li>The execution order of operations</li></ul><p>Tracing gives you visibility into the entire request lifecycle.</p><h3>Step 1: Install Traccia</h3><pre>uv add traccia rich</pre><p>We’re also using Rich to print the final output nicely in the terminal.</p><h3>Step 2: Initialize Traccia</h3><pre>from traccia import init<br><br>init(enable_console_exporter=True)</pre><p>By enabling the console exporter, every traced function automatically prints span information directly in your terminal.</p><h3>Step 3: Create the Order Validation Step</h3><pre>@observe()<br>def validate_order(order):<br>    time.sleep(0.3)<br><br>    if order[&quot;quantity&quot;] &lt;= 0:<br>        raise ValueError(&quot;Quantity must be positive&quot;)<br><br>    return True</pre><p>This function ensures the customer has ordered a valid quantity.</p><h3>Step 4: Check Inventory</h3><pre>@observe()<br>def check_inventory(product_id, quantity):<br>    time.sleep(0.5)<br><br>    stock = random.randint(0, 20)<br><br>    return {<br>        &quot;product_id&quot;: product_id,<br>        &quot;requested&quot;: quantity,<br>        &quot;available&quot;: stock,<br>        &quot;in_stock&quot;: stock &gt;= quantity,<br>    }</pre><p>This simulates an inventory service and determines whether enough products are available.</p><h3>Step 5: Calculate Pricing</h3><pre>@observe()<br>def calculate_price(price, quantity):<br>    time.sleep(0.2)<br><br>    subtotal = price * quantity<br>    tax = subtotal * 0.18<br>    total = subtotal + tax<br><br>    return {<br>        &quot;subtotal&quot;: subtotal,<br>        &quot;tax&quot;: tax,<br>        &quot;total&quot;: total,<br>    }</pre><p>The pricing service calculates:</p><ul><li>Subtotal</li><li>Tax</li><li>Final amount</li></ul><h3>Step 6: Process Payment</h3><pre>@observe()<br>def process_payment(amount):<br>    time.sleep(1)<br><br>    payment_id = f&quot;PAY-{random.randint(1000, 9999)}&quot;<br><br>    return {<br>        &quot;payment_id&quot;: payment_id,<br>        &quot;amount&quot;: amount,<br>        &quot;status&quot;: &quot;SUCCESS&quot;,<br>    }</pre><p>This represents a payment gateway that processes the customer’s payment.</p><h3>Step 7: Orchestrate Everything</h3><pre>@observe()<br>def create_order(order):<br>    validate_order(order)<br><br>    inventory = check_inventory(order[&quot;product_id&quot;], order[&quot;quantity&quot;])<br><br>    if not inventory[&quot;in_stock&quot;]:<br>        raise Exception(f&quot;Only {inventory[&#39;available&#39;]} items available&quot;)<br><br>    pricing = calculate_price(order[&quot;price&quot;], order[&quot;quantity&quot;])<br><br>    payment = process_payment(pricing[&quot;total&quot;])<br><br>    return {<br>        &quot;order_id&quot;: f&quot;ORD-{random.randint(10000, 99999)}&quot;,<br>        &quot;inventory&quot;: inventory,<br>        &quot;pricing&quot;: pricing,<br>        &quot;payment&quot;: payment,<br>    }</pre><p>This function becomes the parent span that coordinates the entire workflow.</p><h3>Running the Application</h3><pre>if __name__ == &quot;__main__&quot;:<br>    order = {<br>        &quot;product_id&quot;: 101,<br>        &quot;quantity&quot;: 2,<br>        &quot;price&quot;: 1500,<br>    }<br><br>    try:<br>        result = create_order(order)<br>        pprint(result)<br><br>    except Exception as e:<br>        print(&quot;Error:&quot;, e)</pre><h3>All in One:</h3><p>You can find all the code and diagrams at the <a href="https://gist.github.com/Rudra-G-23/7e3a68627fa3a2c5734d2c9101242856">link</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d01ea91a166825e1f1da4417525d6088/href">https://medium.com/media/d01ea91a166825e1f1da4417525d6088/href</a></iframe><h3>Terminal Output</h3><p>When you run the application:</p><pre>python main.py</pre><p><strong>Overall Output:</strong></p><pre># I used rich Library for beautiful terminal view <br>{<br>│   &#39;order_id&#39;: &#39;ORD-90117&#39;,<br>│   &#39;inventory&#39;: {<br>│   │   &#39;product_id&#39;: 101,<br>│   │   &#39;requested&#39;: 2,<br>│   │   &#39;available&#39;: 17,<br>│   │   &#39;in_stock&#39;: True<br>│   },<br>│   &#39;pricing&#39;: {<br>│   │   &#39;subtotal&#39;: 3000,<br>│   │   &#39;tax&#39;: 540.0,<br>│   │   &#39;total&#39;: 3540.0<br>│   },<br>│   &#39;payment&#39;: {<br>│   │   &#39;payment_id&#39;: &#39;PAY-2141&#39;,<br>│   │   &#39;amount&#39;: 3540.0,<br>│   │   &#39;status&#39;: &#39;SUCCESS&#39;<br>│   }<br>}</pre><p>Traccia automatically generates spans for every observed function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rkxhY1ODRNzk0rSwkfrcgg.png" /></figure><p>Notice that every function shares the same trace_id. This allows you to reconstruct the entire execution flow of a single order request.</p><h3>Why This Matters in Production</h3><p>This example is small, but real applications often involve:</p><ul><li>Payment services</li><li>Inventory databases</li><li>Shipping systems</li><li>Notification services</li><li>External APIs</li><li>Multiple microservices</li></ul><p>Tracing helps answer questions like:</p><ul><li>Where did the request fail?</li><li>Which service is slow?</li><li>How long does the entire workflow take?</li><li>Which function caused the exception?</li></ul><p>Without tracing, these questions can be difficult to answer.</p><h3>Final Thoughts</h3><p>Adding observability doesn’t have to be complicated.</p><p><a href="https://traccia.ai/docs/sdk/quickstart">SDK Quickstart | Traccia Docs</a></p><p>With a single decorator: @observe()</p><p>How to use Groq with Traccia: simple quick start</p><p><a href="https://medium.com/@rudraprasadbhuyan999/getting-started-with-traccia-groq-9e95c1c47b1b">Getting Started with Traccia + Groq</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38c7dca3d911" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started with Traccia + Groq]]></title>
            <link>https://ai.plainenglish.io/getting-started-with-traccia-groq-9e95c1c47b1b?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e95c1c47b1b</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 04:11:39 GMT</pubDate>
            <atom:updated>2026-06-22T04:16:40.878Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Add Observability to Your LLM Applications in Minutes</blockquote><p>When building AI applications, it’s important to know:</p><ul><li>How long each LLM call takes</li><li>What inputs and outputs are being generated</li><li>Whether your application is performing correctly</li></ul><p>This is where <strong>Traccia</strong> comes in. It provides lightweight observability and tracing for your AI applications.</p><p>In this article, we’ll connect <strong>Traccia</strong> with <strong>Groq</strong> and see our traces directly in the terminal.</p><h3>Step 1: Create a New Project</h3><pre>mkdir traccia-groq-demo<br>cd traccia-groq-demo<br>uv init</pre><h3>Step 2: Install Required Libraries</h3><p>Using uv, Install all dependencies:</p><pre>uv add traccia groq python-dotenv rich</pre><p>This installs:</p><ul><li>traccia → LLM observability and tracing</li><li>groq → Groq Python SDK</li><li>python-dotenv → Load environment variables</li><li>rich → Beautiful terminal output</li></ul><h3>Step 3: Create a .env File</h3><p>Create a file named .env.</p><pre>GROQ_API_KEY=&quot;your_actual_groq_api_key_here&quot;</pre><p>You can generate your API key from: <a href="https://console.groq.com/keys">https://console.groq.com/keys</a></p><p>Groq currently provides a generous free tier, which is more than enough for learning and small projects.</p><h3>Step 4: Your pyproject.toml</h3><p>After installing the libraries, your dependencies section will look similar to this:</p><pre>[project]<br>name = &quot;traccia-groq-demo&quot;<br>version = &quot;0.1.0&quot;<br>requires-python = &quot;&gt;=3.11&quot;<br>dependencies = [<br>    &quot;groq&quot;,<br>    &quot;python-dotenv&quot;,<br>    &quot;rich&quot;,<br>    &quot;traccia&quot;,<br>]</pre><h3>Step 5: Write the Code</h3><p>Create main.py.</p><pre>import os<br>from dotenv import load_dotenv<br>from groq import Groq<br>from rich import print<br>from rich.traceback import install<br>from traccia import init, observe<br><br>install()<br>load_dotenv()<br><br># Enable Traccia console exporter<br>init(enable_console_exporter=True)<br><br># Create Groq client<br>client = Groq(<br>    api_key=os.getenv(&quot;GROQ_API_KEY&quot;)<br>)<br><br>@observe()<br>def call_model(model):<br>    &quot;&quot;&quot;Call Groq model.&quot;&quot;&quot;<br>    chat_completion = model.chat.completions.create(<br>        messages=[<br>            {<br>                &quot;role&quot;: &quot;user&quot;,<br>                &quot;content&quot;: &quot;Explain quantum computing in one sentence&quot;,<br>            }<br>        ],<br>        model=&quot;llama-3.1-8b-instant&quot;,<br>    )<br>    return chat_completion<br><br>if __name__ == &quot;__main__&quot;:<br>    response = call_model(client)<br>    print(response)</pre><h3>Step 6: Run the Application</h3><pre>python main.py</pre><h3>Terminal Output</h3><p>Because we enabled:</p><pre>init(enable_console_exporter=True)</pre><p>Traccia automatically prints tracing information in the terminal.</p><p>Example:</p><pre>[span]<br>name=call_model<br>trace_id=4657ea436673017eb0ba4096cfd8cf31<br>span_id=be69d763c890f984<br>status=OK<br>duration_ns=1226248000</pre><p>And below that, you’ll see the actual model response:</p><pre>Quantum computing is a revolutionary computing paradigm that uses <br>quantum-mechanical phenomena, such as superposition, entanglement, and interference, to perform <br>calculations and operations on data at an exponentially faster scale than classical computers.</pre><p>In my case, the output looks like:</p><blockquote>Output from the LLM side</blockquote><pre>ChatCompletion(<br>    id=&#39;chatcmpl-fa5e399a-7933-41a9-9713-49209c1fd075&#39;,<br>    choices=[<br>        Choice(<br>            finish_reason=&#39;stop&#39;,<br>            index=0,<br>            logprobs=None,<br>            message=ChatCompletionMessage(<br>                content=&#39;Quantum computing is a revolutionary computing paradigm that uses <br>quantum-mechanical phenomena, such as superposition, entanglement, and interference, to perform <br>calculations and operations on data at an exponentially faster scale than classical computers.&#39;,<br>                role=&#39;assistant&#39;,<br>                annotations=None,<br>                executed_tools=None,<br>                function_call=None,<br>                reasoning=None,<br>                tool_calls=None<br>            )<br>        )<br>    ],<br>    created=1782099508,<br>    model=&#39;llama-3.1-8b-instant&#39;,<br>    object=&#39;chat.completion&#39;,<br>    mcp_list_tools=None,<br>    service_tier=&#39;on_demand&#39;,<br>    system_fingerprint=&#39;fp_4387d3edbb&#39;,<br>    usage=CompletionUsage(<br>        completion_tokens=45,<br>        prompt_tokens=44,<br>        total_tokens=89,<br>        completion_time=0.049755558,<br>        completion_tokens_details=None,<br>        prompt_time=0.002488246,<br>        prompt_tokens_details=None,<br>        queue_time=0.052845454,<br>        total_time=0.052243804<br>    ),<br>    usage_breakdown=None,<br>    x_groq=XGroq(id=&#39;req_01kvppgz9gfznbt7q24t6z9r8x&#39;, debug=None, seed=1151134391, usage=None)<br>)</pre><blockquote>Output from the Traccia side:</blockquote><pre>[span] name=call_model trace_id=4657ea436673017eb0ba4096cfd8cf31 span_id=be69d763c890f984 status=OK duration_ns=1226248000 attrs={&#39;result&#39;: &quot;ChatCompletion(id=&#39;chatcmpl-fa5e399a-7933-41a9-9713-49209c1fd075&#39;, choices=[Choice(finish_reason=&#39;stop&#39;, index=0, logprobs=None, message=ChatCompletionMessage(content=&#39;Quantum computing is a revolutionary computing paradigm that uses quantum-mechanical phenomena, such as superposition, entanglement, and interference, to perform calculations and operations on data at an exponentially faster scale than classical computers.&#39;, role=&#39;assistant&#39;, annotations=None, executed_tools=None, function_call=None, reasoning=None, tool_calls=None))], created=1782099508, model=&#39;llama-3.1-8b-instant&#39;, object=&#39;chat.completion&#39;, mcp_list_tools=None, service_tier=&#39;on_demand&#39;, system_fingerprint=&#39;fp_4387d3edbb&#39;, usage=CompletionUsage(completion_tokens=45, prompt_tokens=44, total_tokens=89, completion_time=0.049755558, completion_tokens_details=None, prompt_time=0.002488246, prompt_tokens_details=None, queue_time=0.052845454, total_time=0.052243804), usage_breakdown=None, x_groq=XGroq(id=&#39;req_01kvppgz9gfznbt7&quot;, &#39;model&#39;: &#39;&lt;groq.Groq object at 0x0000029773B74980&gt;&#39;, &#39;span.type&#39;: &#39;llm&#39;, &#39;llm.model&#39;: &#39;&lt;groq.Groq object at 0x0000029773B74980&gt;&#39;, &#39;agent.id&#39;: &#39;__main__&#39;, &#39;agent.name&#39;: &#39;__main__&#39;, &#39;agent.type&#39;: &#39;workflow&#39;, &#39;agent.description&#39;: &#39;&#39;, &#39;env&#39;: &#39;production&#39;, &#39;environment&#39;: &#39;production&#39;, &#39;guardrail.summary&#39;: &#39;{&quot;detected_categories&quot;: [], &quot;triggered_categories&quot;: [], &quot;missing_categories&quot;: [], &quot;coverage_confidence&quot;: &quot;low&quot;, &quot;capabilities_observed&quot;: [&quot;calls_llm&quot;], &quot;limitations&quot;: [&quot;No guardrail signals detected in trace; agent may have out-of-band guardrails not visible to tracing.&quot;]}&#39;, &#39;guardrail.summary.detected_categories&#39;: [], &#39;guardrail.summary.missing_count&#39;: 0, &#39;guardrail.summary.coverage_confidence&#39;: &#39;low&#39;, &#39;governance.event_type&#39;: &#39;inference&#39;, &#39;governance.timestamp_source&#39;: &#39;sdk&#39;}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5CfyRpy4R1rK12FgHXPmQg.png" /></figure><h3>Why Use Traccia?</h3><p><a href="https://github.com/traccia-ai/traccia-py">GitHub - traccia-ai/traccia-py: OpenTelemetry-native observability, governance, and compliance for AI agents and LLM applications</a></p><p>With just one decorator: <strong>@observe()</strong></p><p>you get:</p><ul><li>Function execution traces</li><li>Duration monitoring</li><li>Easier debugging</li><li>Better visibility into your LLM application</li><li>A foundation for production-grade observability</li></ul><h3>Final Thoughts</h3><p>Observability becomes increasingly important as your AI applications grow. Combining <strong>Groq’s fast inference</strong> with <strong>Traccia’s tracing capabilities</strong> gives you a simple yet powerful setup for monitoring your LLM applications.</p><p>The entire integration takes less than five minutes, but it can save hours of debugging later.</p><p>Happy building!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e95c1c47b1b" width="1" height="1" alt=""><hr><p><a href="https://ai.plainenglish.io/getting-started-with-traccia-groq-9e95c1c47b1b">Getting Started with Traccia + Groq</a> was originally published in <a href="https://ai.plainenglish.io/">Artificial Intelligence in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI coding for Real Engineer]]></title>
            <link>https://medium.com/@rudraprasadbhuyan999/ai-coding-for-real-engineer-d719e0688440?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/d719e0688440</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Sat, 25 Apr 2026 17:37:51 GMT</pubDate>
            <atom:updated>2026-04-25T17:37:51.232Z</atom:updated>
            <content:encoded><![CDATA[<p>My notes of Matt Pocockuk YT Workshop</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F-QFHIoCo-Ko%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D-QFHIoCo-Ko&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F-QFHIoCo-Ko%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/f27efaf79e0d5f528cba76cdfd3c303e/href">https://medium.com/media/f27efaf79e0d5f528cba76cdfd3c303e/href</a></iframe><h3>Why ?</h3><ul><li>Just for learning &amp; Curiosity</li><li>Learn How to code with LLM and make software</li></ul><h3>What we learn</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OA8IdNojNann_aIWv-gq8w.jpeg" /></figure><ul><li>Note Date: Sat 25, Apr 2026</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a59HSFuBIlx3DtAbrgpxYQ.jpeg" /></figure><h4>Smart Zoone</h4><ul><li>Context Window is limit us.</li><li>If we go beyond the limit then this generate random code that not make any sense.</li><li>So we need to break long task into smaller works within limit of context window.</li></ul><h4>Break the Task</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TiKbl3KHYYBTjbaxuGi2Jg.jpeg" /></figure><ul><li>Break the Task into smaller PRD.</li><li>PRD: Product Requirement Document</li><li>So AI can know what to do and think <em>which direction need to think.</em></li></ul><h4><em>Clearing</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NHSzQQBMXwBsuGMK9Y_QAg.jpeg" /></figure><ul><li>The gray area or context is the PRD.</li><li>When we do <strong>/clear —</strong> It came back to normal stage which is ideation and thinking.</li></ul><h4>Compact</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tR-pklbZDhkt8y62TklGJQ.jpeg" /></figure><ul><li>Then the<strong><em> /compact</em></strong> — This is summary generator of above discussion and questions answer we did before.</li></ul><h4>grill-me</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B5OQn1uAkGmlVhNg9-2ZEA.jpeg" /></figure><ul><li><strong>/grill-me — </strong>This is the what is skills section to drill down what I think and find what works for me.</li></ul><h4>Sub-Agents</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6LSaOdj60teaUqY-sbpLww.jpeg" /></figure><ul><li>Sub-Agents: This is the subscription agent used and structure our code and explore</li></ul><h4>Destination → Journey</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_XHXPFY5ROnbGcIcGCam3A.jpeg" /></figure><ul><li>After grill-me @ store-in-a-file</li><li>We trigger the <strong>/write-a-prd — </strong>This helps to write the PRD from our destination and we start our journey.</li></ul><h4>System layers</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3AgKPaGTVeVZ7u1kFeNK1w.jpeg" /></figure><ul><li>We know we design the software layer by layer</li><li>but with ai we need to go with different approaches</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JIP4kFiEzYzBT33v7skfJQ.jpeg" /></figure><ul><li>If we do horizontally then until we finished the application we don’t know how this work and what are issues so we do</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xqOp4T2CJAvXv4bwzzujiA.jpeg" /></figure><ul><li>We need to do a<strong> /prd-to-issues —</strong> the agents working styles (How the agents works overall)</li><li>Which agent what do</li></ul><h4>TTD</h4><p>TDD stands for Test-Driven Development.</p><ul><li>A &quot;red-green-refactor&quot; cycle:</li><li><strong>Red</strong>: The AI first writes a failing test for a specific task or feature .</li><li><strong>Green</strong>: The AI then writes the minimum amount of code required to make that test pass .</li><li><strong>Refactor</strong>: The code is cleaned up and improved while ensuring the tests still pass.</li></ul><blockquote>Quality of feedback loop</blockquote><h4>How to Test</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qsd5o-yocpzaccZ1VBuLoQ.jpeg" /></figure><ul><li>How a good database look like</li><li>If AI test only small small function and in other corner function it affects others we can’t catch.</li><li>so we need to create <em>deep module</em> for this.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Aria6JLoVcE8FZoK4mLT7Q.jpeg" /></figure><ul><li>Deep module means during PRD time plan how each module compact and integrated each other.</li><li>So create a skills <em>improve- codebase-architecture.md</em></li><li>This scan the overall module and test create a good feedback loop.</li><li>If PRD is done then don’t have for a long time. because ai comfused if we year after change something.</li></ul><p>Tell me</p><p>If you found my notes helpfull.</p><p>Thank you 💜</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d719e0688440" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[If Evryone’s Hiring … Why can’t You got a Job ?]]></title>
            <link>https://medium.com/@rudraprasadbhuyan999/if-evryones-hiring-why-can-t-you-got-a-job-3674a2b715e3?source=rss-53d039b2c456------2</link>
            <guid isPermaLink="false">https://medium.com/p/3674a2b715e3</guid>
            <category><![CDATA[hr]]></category>
            <category><![CDATA[data-analyst]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[jobs]]></category>
            <dc:creator><![CDATA[Rudra Prasad Bhuyan]]></dc:creator>
            <pubDate>Fri, 24 Apr 2026 12:22:41 GMT</pubDate>
            <atom:updated>2026-04-24T15:05:49.448Z</atom:updated>
            <content:encoded><![CDATA[<p>If job is posting why you are not hired?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*17FBZslIxXRo-lEQ" /><figcaption>Photo by <a href="https://unsplash.com/@microsoftcopilot?utm_source=medium&amp;utm_medium=referral">Microsoft Copilot</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I applied nearly the 200 + jobs from the LinkedIn or other job portal.</p><p>but I got nothing …</p><p>From LinkedIn I apply 200+ but got nothing.</p><p>I got no email of rejection.</p><p>I am literally frustrated and also overwhelmed.</p><p>Date: Fri 24 Apr, 2026</p><h3>Reason:</h3><p>Then I understand one word called</p><blockquote>Gost Job</blockquote><p>that means a job which is not exist in real life, company not hire this a just a loop.</p><h3>Why company postings gost Job</h3><p>I got the three reason why</p><ol><li><strong>Building Pipeline:</strong> companies are doing because they are finding for the perfect candidate which can do the three of work with a single payment.</li><li><strong>Apperance &amp; Compliance</strong>: Investors think company are growing &amp; HR work is posting, they do for fun.</li><li><strong>Leverage</strong>: if HR post for the new job roll then internal employee think maybe someone is fire from our company so the companies has the new guy in this way they can exploit the internal company without improve being the salary.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*d2q-xF4hGBNt30eo" /><figcaption>Photo by <a href="https://unsplash.com/@theblowup?utm_source=medium&amp;utm_medium=referral">the blowup</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Impacts</h3><p>First of all like me a fresher I stop believing the original posting and I think everything is just for a fake PR &amp; Marketing.</p><p>My mind not find the way it is just copy paste. No learning no growth.</p><ul><li>Exhausted from waiting and applying for job.</li><li>Time and lot of time waste</li><li>Opportunity cost: decide applying the ghost job if I did something more valuable than it helps me.</li></ul><figure><img alt="Misinformation on the web. Illustration by Carlos PX (http://payforlayers.com/)" src="https://cdn-images-1.medium.com/max/1024/0*TeGYPe2dyIcLdRoL" /><figcaption>Photo by <a href="https://unsplash.com/@visuals?utm_source=medium&amp;utm_medium=referral">visuals</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Fake Market</h3><p>After that we are applying and also in India that is called the fake market also exist.</p><ul><li>when you are applying</li><li>Got the mail you have an Offer letter</li><li>Then you verify the company</li><li>Company are selling their internship work.</li><li>Just pure recordings of YouTube video and pay me the 1000₹ or 2000 rupees.</li><li>Time Waste</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Inp1LT1zWzecJSY-" /><figcaption>Photo by <a href="https://unsplash.com/@averieclaire?utm_source=medium&amp;utm_medium=referral">averie woodard</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>How to save yourself:</h3><h4><strong>Regular Posting /Scheduling:</strong></h4><ul><li>Same JD share in the interval of time</li><li>First of all if any post looks like regular having the more emoji than most probably it is fake.</li><li>same title same emoji and same evrything.</li></ul><h4><strong>Follow and Comment</strong></h4><ul><li>Few of people they are using this job postings for getting more followers.</li><li>In the description said — Follow Me, Like and share</li><li>Comment “Interesting”</li><li>Too much hashtags</li></ul><h4>Lack of Clarity</h4><ul><li>They are the posting the job description but they also don’t know what they are posting.</li><li>No fix timeline</li><li>No proper link or email ID</li><li>If they provide the email ID then that is not exist.</li></ul><h4>Automates Silence</h4><ul><li>There hiring for the on usual title</li><li>Unexpected salary Range</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3674a2b715e3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>