<?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 Sharry Stowell on Medium]]></title>
        <description><![CDATA[Stories by Sharry Stowell on Medium]]></description>
        <link>https://medium.com/@sharrystowell?source=rss-3d155fc11b5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*6HDjlIgHXA3RHgceTPvqFw.jpeg</url>
            <title>Stories by Sharry Stowell on Medium</title>
            <link>https://medium.com/@sharrystowell?source=rss-3d155fc11b5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 02:11:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sharrystowell/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[Building My First RAG System]]></title>
            <link>https://medium.com/@sharrystowell/building-my-first-rag-system-194032c89f19?source=rss-3d155fc11b5------2</link>
            <guid isPermaLink="false">https://medium.com/p/194032c89f19</guid>
            <category><![CDATA[agentic-rag]]></category>
            <category><![CDATA[vector-database]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Sharry Stowell]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 07:42:36 GMT</pubDate>
            <atom:updated>2026-07-10T07:42:36.878Z</atom:updated>
            <content:encoded><![CDATA[<p>Over the last few months I’ve spent a lot of time reading about AI, LLMs and chatbots. One term that kept appearing was RAG.</p><p><strong>R</strong>etrieval <strong>A</strong>ugmented <strong>G</strong>eneration.</p><p>It sounded far more complicated than it actually is.</p><p>Once I dug into it, I realised most RAG systems are built from a handful of fairly simple pieces.</p><p>The clever part comes from how those pieces fit together.</p><h3>Why I Started Looking At RAG</h3><p>One thing quickly became obvious when experimenting with large language models.</p><p>They’re good at answering general questions.</p><p>They’re much less reliable when you ask about information they haven’t seen before.</p><p>Let’s say I have 10,000 internal company documents.</p><p>Or a large archive of historical posts.</p><p>Or thousands of PDF reports.</p><p>A normal LLM won’t know anything about them.</p><p>That’s where RAG comes in.</p><p>Instead of relying purely on what the model already knows, we fetch relevant information first and include it in the prompt.</p><p>The model can then answer questions using that information.</p><h3>The Basic Flow</h3><p>At a high level a RAG system looks something like this:</p><blockquote>Documents<br> ↓<br>Chunking<br> ↓<br>Embeddings<br> ↓<br>Vector Database<br> ↓<br>Similarity Search<br> ↓<br>LLM Prompt<br> ↓<br>Response</blockquote><p>There are a few extra details in production systems, but that’s the general idea.</p><h3>Step 1 - Loading Documents</h3><p>For my first experiment I used a handful of text files.</p><p>Nothing fancy.</p><pre>from pathlib import Path<br><br>documents = []<br><br>for file in Path(&quot;./documents&quot;).glob(&quot;*.txt&quot;):<br>    documents.append(<br>        file.read_text(<br>            encoding=&quot;utf-8&quot;<br>        )<br>    )<br><br>print(<br>    f&quot;Loaded {len(documents)} documents&quot;<br>)</pre><p>The goal wasn’t to build a production system.</p><p>I just wanted to understand the workflow.</p><h3>Step 2 - Chunking</h3><p>Large documents need splitting into smaller sections.</p><p>This process is called chunking.</p><pre>def chunk_text(<br>    text,<br>    chunk_size=500<br>):<br>    chunks = []<br><br>    for i in range(<br>        0,<br>        len(text),<br>        chunk_size<br>    ):<br>        chunks.append(<br>            text[i:i+chunk_size]<br>        )<br><br>    return chunks</pre><p>There are far more sophisticated approaches.</p><p>For a first attempt though, this worked well enough.</p><h3>Step 3 - Generating Embeddings</h3><p>Embeddings are what make semantic search possible.</p><p>Instead of storing raw text, we convert each chunk into a numerical representation.</p><p>Similar chunks end up close together in vector space.</p><p>I used OpenAI embeddings for my first experiment.</p><pre>from openai import OpenAI<br><br>client = OpenAI()<br><br>response = client.embeddings.create(<br>    model=&quot;text-embedding-3-small&quot;,<br>    input=chunk<br>)<br><br>embedding = response.data[0].embedding</pre><p>At this point I had:</p><ul><li>Document chunks</li><li>Embeddings</li><li>Metadata</li></ul><p>Now I needed somewhere to store them.</p><h3>Step 4 - Storing Vectors</h3><p>For my first version I used a simple vector database.</p><p>There are plenty of options available:</p><ul><li>Pinecone</li><li>Weaviate</li><li>Qdrant</li><li>Chroma</li></ul><p>I chose Chroma because it was easy to get running locally.</p><pre>collection.add(<br>    documents=[chunk],<br>    embeddings=[embedding],<br>    ids=[chunk_id]<br>)</pre><p>A few minutes later I had searchable vectors.</p><h3>Step 5 - Retrieving Context</h3><p>This is where things started getting interesting.</p><p>When a user asks a question:</p><blockquote>What happened to the harbour in 1954?</blockquote><p>We first search for the most relevant chunks.</p><pre>results = collection.query(<br>    query_embeddings=[<br>        query_embedding<br>    ],<br>    n_results=5<br>)</pre><p>The system returns the chunks most closely related to the question.</p><h3>Step 6 - Building The Prompt</h3><p>Instead of sending only the user’s question to the LLM, we send the retrieved context as well.</p><pre>prompt = f&quot;&quot;&quot;<br>Answer the question using<br>the supplied context.<br><br>Context:<br>{context}<br><br>Question:<br>{question}<br>&quot;&quot;&quot;</pre><p>The model now has information it didn’t previously know.</p><p>That’s the magic behind RAG.</p><p>Not the retrieval.</p><p>Not the vector database.</p><p>The fact that we’re supplying useful context at the right moment.</p><h3>My First Mistake</h3><p>My initial chunks were far too large.</p><p>The search results looked relevant, but often contained lots of unrelated information.</p><p>Smaller chunks improved retrieval quite a bit.</p><p>I also discovered that retrieval quality matters far more than model quality.</p><p>A powerful model given poor context still produces poor answers.</p><h3>Where I Think This Is Going</h3><p>What interests me most isn’t chatbots.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=194032c89f19" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Treated Claude Like a Better ChatGPT. Then Everything Changed.]]></title>
            <link>https://medium.com/@sharrystowell/i-treated-claude-like-a-better-chatgpt-then-everything-changed-ede34543ef18?source=rss-3d155fc11b5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ede34543ef18</guid>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[chatgpt]]></category>
            <dc:creator><![CDATA[Sharry Stowell]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 12:00:03 GMT</pubDate>
            <atom:updated>2026-07-10T08:31:59.849Z</atom:updated>
            <content:encoded><![CDATA[<h4>For the first few months I used Claude completely wrong.</h4><p>Not disastrously wrong. I still got value from it. It wrote functions, explained code and occasionally saved me from spending half an hour digging through documentation.</p><p>The problem was that I was treating it like a chatbot.</p><p>I’d open Claude, paste some code, ask a question, copy the answer and move on.</p><p>It was basically Stack Overflow with better manners.</p><p>At the time I thought I was being productive.</p><p>Looking back, I was barely scratching the surface.</p><h3>The Realisation</h3><p>One evening I was working on a Python project and found myself bouncing between four different windows.</p><p>One terminal.</p><p>VS Code.</p><p>A browser tab with documentation.</p><p>Claude in another browser tab.</p><p>I’d ask Claude a question, switch back to my editor, make some changes, run the code, switch back again, ask another question and repeat the process.</p><p>After a few hours I realised something.</p><p>I was spending more time managing the conversation than writing software.</p><p>The AI wasn’t the bottleneck.</p><p><em>I was.</em></p><h3>Thinking Bigger</h3><p>The breakthrough came when I stopped asking Claude to solve individual problems.</p><p>Instead I started giving it context.</p><p>Lots of context.</p><p>Rather than saying:</p><blockquote>Write a function to parse this CSV file.</blockquote><p>I’d say:</p><blockquote>This is a vessel reporting system. The CSV files arrive daily from multiple suppliers. The data quality is inconsistent and we need to process around 100,000 rows per day. Here’s the existing implementation.</blockquote><p>The quality of the answers improved immediately.</p><p>Not because Claude became smarter.</p><p>Because I’d finally given it enough information to understand the problem.</p><p>That sounds obvious now, but it took me longer than I’d like to admit.</p><h3>Claude Became My Second Pair Of Eyes</h3><p>One of the first genuinely useful workflows I discovered was code reviews.</p><p>Instead of asking Claude to generate code, I’d ask it to review code I’d already written.</p><p>Something like:</p><blockquote>Review this implementation. Look for bugs, edge cases, performance issues and security concerns.</blockquote><p>The results were surprisingly good.</p><p>Not perfect.</p><p>Far from it.</p><p>But it regularly spotted things I’d missed after staring at the same code for three hours.</p><p>A missing null check.</p><p>An inefficient database query.</p><p>An API timeout I hadn’t considered.</p><p>The sort of things another developer might pick up during a pull request review.</p><h3>The Documentation Problem</h3><p>Like most developers, I hate writing documentation.</p><p>I know it’s important.</p><p>I still don’t enjoy it.</p><p>Claude changed that.</p><p>Rather than asking it to generate documentation from scratch, I started feeding it code and asking it to explain the intent.</p><p>That produced much better results.</p><p>The generated documentation wasn’t perfect, but it was usually good enough to get me from zero percent complete to eighty percent complete.</p><p>The remaining twenty percent was easy.</p><h3>Learning New Technologies Faster</h3><p>One area where Claude genuinely shines is helping me learn unfamiliar technology.</p><p>Recently I’ve been spending more time looking at things like:</p><ul><li>SageMaker</li><li>RAG</li><li>Snowflake</li><li>Kinesis</li><li>MLOps</li></ul><p>Normally that would involve reading dozens of blog posts and documentation pages.</p><p>I still read the documentation.</p><p>The difference is that now I have something that can answer follow-up questions immediately.</p><p>When a piece of documentation assumes prior knowledge, Claude can fill in the gaps.</p><p>That sounds small.</p><p>It’s not.</p><p>Removing those little moments of friction makes learning much faster.</p><h3>The Mistake I Still See Developers Making</h3><p>A lot of developers treat AI like a search engine.</p><p>They ask tiny questions.</p><p>They provide almost no context.</p><p>Then they’re disappointed with the answer.</p><p>It’s a bit like asking a new team member:</p><blockquote>Fix this bug.</blockquote><p>without showing them the codebase.</p><p>Without explaining the business requirements.</p><p>Without explaining the architecture.</p><p>Without explaining the problem.</p><p>You wouldn’t expect great results.</p><p>Neither should you expect great results from AI.</p><p>Context matters.</p><p>Probably more than the prompt itself.</p><h3>What Claude Still Gets Wrong</h3><p>It’s easy to get carried away and assume AI can do everything.</p><p>It can’t.</p><p>Claude still confidently suggests things that don’t exist.</p><p>It occasionally invents APIs.</p><p>It sometimes recommends approaches that look sensible but fall apart under real-world usage.</p><p>That’s why I never blindly copy code into production.</p><p>The more experience I gain as a developer, the more I realise Claude works best as an accelerator rather than a replacement.</p><p>It helps me move faster.</p><p>It doesn’t remove the need to think.</p><h3>Where I Am Now</h3><p>These days Claude is involved in almost every project I work on.</p><p>Not because it writes all the code.</p><p>Because it reduces friction.</p><p>It helps me understand unfamiliar systems.</p><p>It reviews ideas.</p><p>It challenges assumptions.</p><p>It explains technologies.</p><p>It helps me learn.</p><p>Looking back, I didn’t waste those first six months.</p><p>I learned how not to use it.</p><p>That turned out to be just as valuable.</p><p>I’m Sharry, a software engineer from Norfolk. I write about AWS, AI, cloud architecture, TypeScript, Python and side projects. More articles: <a href="https://sharry.im/">https://sharry.im</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ede34543ef18" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Problem Does SageMaker Solve?]]></title>
            <link>https://medium.com/@sharrystowell/what-problem-does-sagemaker-solve-5e0c2ab16f0a?source=rss-3d155fc11b5------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e0c2ab16f0a</guid>
            <category><![CDATA[sagemaker]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Sharry Stowell]]></dc:creator>
            <pubDate>Sat, 07 Mar 2026 12:00:08 GMT</pubDate>
            <atom:updated>2026-07-10T08:23:18.580Z</atom:updated>
            <content:encoded><![CDATA[<h4>Before looking at SageMaker itself, it’s worth thinking about what machine learning projects often look like.</h4><p>The data might live in <a href="https://aws.amazon.com/s3/">S3</a>. Some processing happens in <a href="https://aws.amazon.com/glue/">Glue</a>. Someone runs queries in <a href="https://aws.amazon.com/athena/">Athena</a>. Models get trained somewhere else. Then there’s another process for deployment.</p><p>Nothing wrong with that. It works.</p><p>The problem is that people end up jumping between lots of different tools. After a while it can feel like you’re spending more time moving data around than actually building anything.</p><p>That’s one of the things <a href="https://aws.amazon.com/sagemaker/">SageMaker </a>tries to improve. It gives data engineers, analysts and machine learning teams a shared place to work from.</p><h3>Creating a Simple Notebook</h3><p>One of the first things I tried was a notebook.</p><p>If you’ve worked with Python before, you’ll probably feel at home straight away.</p><pre>import pandas as pd<br><br>df = pd.read_csv(&quot;customers.csv&quot;)<br>print(df.head())<br>print(df.describe())</pre><p>Not exactly ground breaking.</p><p>Still, it’s a good place to start. You can explore data, test ideas and connect to other AWS services without spending half the morning configuring a development environment.</p><h3>Training a Simple Model</h3><p>For a quick example, let’s imagine we’re trying to predict customer churn.</p><pre>from sklearn.model_selection import train_test_split<br>from sklearn.ensemble import RandomForestClassifier<br><br>X = df.drop(&quot;churn&quot;, axis=1)<br>y = df[&quot;churn&quot;]<br>X_train, X_test, y_train, y_test = train_test_split(<br>  X,<br>  y,<br>  test_size=0.2,<br>  random_state=42<br>)<br><br>model = RandomForestClassifier()<br>model.fit(X_train, y_train)<br>score = model.score(X_test, y_test)<br>print(f&quot;Accuracy: {score}&quot;)</pre><p>I’m deliberately using <a href="https://scikit-learn.org/">scikit-learn</a> here rather than SageMaker-specific features.</p><p>Whenever I’m learning a new platform, I like to understand what’s happening underneath before introducing more layers of abstraction.</p><p>Maybe that’s just the old-school developer in me.</p><h3>SageMaker Feature Store</h3><p>One area that caught my attention was Feature Store.</p><p>I’ve seen projects where the model wasn’t the difficult part. The difficult part was making sure everyone agreed on what the inputs actually were.</p><p>Take something like:</p><pre>customer_age_days<br>average_order_value<br>orders_last_30_days</pre><p>Seems simple enough.</p><p>Then you discover three teams have calculated those values in slightly different ways.</p><p>A shared feature store helps avoid that problem. Everybody works from the same definitions instead of maintaining their own versions in notebooks and scripts scattered across the company.</p><h3>Where I Think Things Get Interesting</h3><p>The machine learning side is useful, but what really interests me is where all of this is heading.</p><p>SageMaker is starting to sit alongside services like <a href="https://aws.amazon.com/bedrock/">Bedrock</a>, vector databases and RAG systems.</p><p>Most businesses already have mountains of information sitting in databases, PDFs, spreadsheets and internal applications. Getting hold of the data has never really been the issue.</p><p>Making it useful is the hard bit.</p><p>That’s the area I’ll be spending more time exploring over the next few months.</p><h3>First Impressions</h3><p>My first impression is that SageMaker has grown into something much bigger than a model training service.</p><p>There are still parts I haven’t touched yet. MLOps, model deployment and large-scale training are all areas I need to spend more time with.</p><p>For now though, it’s a platform I’m glad I finally started looking at properly.</p><p>I’m Sharry, a software engineer from Norfolk.</p><p>I write about AWS, AI, cloud architecture, TypeScript, Python and side projects.</p><p>More articles:<br><a href="https://sharry.im/">https://sharry.im</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e0c2ab16f0a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Training Your First Model with SageMaker]]></title>
            <link>https://medium.com/@sharrystowell/training-your-first-model-with-sagemaker-f3290ae44dd2?source=rss-3d155fc11b5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3290ae44dd2</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[sagemaker]]></category>
            <category><![CDATA[large-language-models]]></category>
            <dc:creator><![CDATA[Sharry Stowell]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 12:00:49 GMT</pubDate>
            <atom:updated>2026-07-10T07:58:33.659Z</atom:updated>
            <content:encoded><![CDATA[<h4>After spending some time looking around SageMaker, I decided it was finally time to train a model.</h4><p>Nothing fancy.</p><p>No LLMs.</p><p>No deep learning.</p><p>Just a simple classification model to understand the basics.</p><p>That’s something I’ve learned over the years. Whenever I’m learning a new platform, I try to keep the problem simple. If everything breaks, at least I know it isn’t because I’ve built something overly complicated.</p><h3>The Dataset</h3><p>For this example I used a simple customer churn dataset.</p><p>The goal is straightforward:</p><p>Can we predict whether a customer is likely to leave based on historical information?</p><p>The data looked something like this:</p><pre>age,monthly_spend,contracts,churn<br>32,85,3,0<br>47,120,1,1<br>25,60,2,0<br>58,140,1,1</pre><p>Nothing unusual there.</p><p>A few columns of customer information and a churn flag showing whether the customer stayed or left.</p><h3>Loading The Data</h3><p>I uploaded the dataset to S3 and opened a SageMaker notebook.</p><p>From there I loaded the data using pandas.</p><pre>import pandas as pd<br><br>df = pd.read_csv(&quot;customer-churn.csv&quot;)<br>print(df.head())</pre><p>The first thing I normally do is check the data.</p><p>Not the model.</p><p>The data.</p><p>I’ve lost count of how many times I’ve spent ages debugging code only to discover the dataset was missing values or contained something unexpected.</p><h3>Preparing The Data</h3><p>Before training a model we need to split the data into training and testing sets.</p><pre>from sklearn.model_selection import train_test_split<br><br>X = df.drop(&quot;churn&quot;, axis=1)<br>y = df[&quot;churn&quot;]<br>X_train, X_test, y_train, y_test = train_test_split(<br>    X,<br>    y,<br>    test_size=0.2,<br>    random_state=42<br>)</pre><p>Pretty standard stuff.</p><p>Eighty percent of the data is used for training.</p><p>The remaining twenty percent is used to see how well the model performs against data it hasn’t seen before.</p><h3>Training A Model</h3><p>For a first attempt I used a Random Forest classifier.</p><p>There are plenty of other algorithms available but this one is usually easy to work with and gives reasonable results.</p><pre>from sklearn.ensemble import RandomForestClassifier<br><br>model = RandomForestClassifier(<br>    n_estimators=100,<br>    random_state=42<br>)<br>model.fit(X_train, y_train)</pre><p>Training took a few seconds.</p><p>That’s one of the nice things about small datasets. You can experiment quickly.</p><h3>Evaluating The Results</h3><p>Once training finished I wanted to see how well the model performed.</p><pre>from sklearn.metrics import accuracy_score<br><br>predictions = model.predict(X_test)<br>accuracy = accuracy_score(<br>    y_test,<br>    predictions<br>)<br>print(f&quot;Accuracy: {accuracy:.2f}&quot;)</pre><p>On my sample dataset I got an accuracy score of around 0.84.</p><p>That sounds good.</p><p>Maybe.</p><p>Accuracy can be misleading.</p><p>If ninety percent of your customers stay anyway, a model that always predicts “stay” will look impressive while being completely useless.</p><p>That’s why it’s important to look beyond a single number.</p><h3>Looking At Feature Importance</h3><p>One thing I found useful was checking which features influenced the model most.</p><pre>feature_importance = pd.DataFrame(<br>    {<br>        &quot;feature&quot;: X.columns,<br>        &quot;importance&quot;: model.feature_importances_<br>    }<br>)<br><br>print(<br>    feature_importance.sort_values(<br>        by=&quot;importance&quot;,<br>        ascending=False<br>    )<br>)</pre><p>This gives a rough idea of what the model thinks matters.</p><p>Sometimes the results are obvious.</p><p>Sometimes they’re surprising.</p><p>Sometimes they reveal problems in the dataset.</p><h3>Where SageMaker Fits In</h3><p>At this point you might be wondering:</p><p>Why not just run all of this on a laptop?</p><p>For a small dataset, you probably can.</p><p>The advantage of SageMaker starts to become clearer when:</p><ul><li>datasets get larger</li><li>teams need to collaborate</li><li>models need deploying</li><li>training becomes expensive</li><li>governance becomes important</li></ul><p>I’m nowhere near training billion-parameter models.</p><p>Right now I’m simply learning the platform and understanding how the pieces fit together.</p><h3>What’s Next?</h3><p>The next thing I want to look at is model deployment.</p><p>Training a model is one thing.</p><p>Making it available through an API so other applications can use it is where things start becoming more interesting.</p><p>That’s probably where I’ll spend my next evening.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3290ae44dd2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding MLOps]]></title>
            <link>https://medium.com/@sharrystowell/understanding-mlops-ffa01ed41d4c?source=rss-3d155fc11b5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ffa01ed41d4c</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[mlops]]></category>
            <dc:creator><![CDATA[Sharry Stowell]]></dc:creator>
            <pubDate>Sat, 10 Jan 2026 12:00:33 GMT</pubDate>
            <atom:updated>2026-07-10T07:52:42.129Z</atom:updated>
            <content:encoded><![CDATA[<h4>Over the last few weeks I’ve been spending more time looking at machine learning on AWS. One term that keeps appearing is MLOps.</h4><p>At first I assumed it was simply DevOps with a different name.</p><p>After digging into it a bit more, that’s not really the case.</p><p>There are similarities. Version control, automation and deployment all play a part. The difference is that machine learning introduces a whole new set of problems that traditional software development doesn’t have to deal with.</p><h3>The Problem</h3><p>Let’s imagine you’ve built a model that predicts customer churn.</p><p>You train it.</p><p>You test it.</p><p>The results look good.</p><p>Job done?</p><p>Not quite.</p><p>A web application deployed today will usually behave the same tomorrow if nobody changes the code.</p><p>Machine learning models are different.</p><p>The world changes.</p><p>Customer behaviour changes.</p><p>Data changes.</p><p>The model that achieved 92% accuracy six months ago might only achieve 75% accuracy today.</p><p>This is often referred to as model drift.</p><p>That’s one of the reasons MLOps exists.</p><h3>Traditional Software Delivery</h3><p>Most developers are familiar with a workflow that looks something like this:</p><pre>Write code<br>Run tests<br>Create pull request<br>Deploy application<br>Monitor system</pre><p>Pretty straightforward.</p><p>You know exactly what code is running in production.</p><p>If there’s a problem you can roll back to an earlier version.</p><h3>Machine Learning Delivery</h3><p>Machine learning introduces extra moving parts.</p><p>Now you’re dealing with:</p><pre>Source code<br>Training data<br>Feature engineering<br>Model training<br>Model evaluation<br>Model deployment<br>Model monitoring</pre><p>The model itself becomes another artefact that needs tracking and managing.</p><p>Two developers can run exactly the same training code and get different results if they’re using different datasets.</p><p>That’s where things start becoming interesting.</p><h3>Versioning Everything</h3><p>One concept that makes a lot of sense is treating data as a versioned asset.</p><p>Most teams already version control their source code.</p><p>MLOps extends that idea.</p><p>You want to know:</p><ul><li>Which code trained the model?</li><li>Which dataset was used?</li><li>Which features were included?</li><li>Which hyperparameters were chosen?</li><li>Which model was deployed?</li></ul><p>Without that information troubleshooting becomes difficult very quickly.</p><p>Imagine discovering a model has started producing poor predictions six months after deployment.</p><p>If nobody knows which data was used to train it, you’re going to have a bad day.</p><h3>A Simple Training Pipeline</h3><p>Let’s imagine we have a small churn prediction model.</p><p>A typical workflow might look like this:</p><pre>data = load_data()</pre><pre>features = engineer_features(data)</pre><pre>model = train_model(features)</pre><pre>score = evaluate_model(model)</pre><pre>if score &gt; 0.85:<br>    deploy_model(model)</pre><p>Simple enough.</p><p>The challenge isn’t writing the code.</p><p>The challenge is making sure the process runs consistently every time.</p><h3>Monitoring Matters</h3><p>One thing I’ve learned from software engineering is that deployment isn’t the finish line.</p><p>It’s usually the start.</p><p>The same applies to machine learning.</p><p>You need visibility into:</p><pre>Prediction volume<br>Latency<br>Error rates<br>Model accuracy<br>Data drift</pre><p>If customer behaviour changes significantly, your model may quietly become less useful over time.</p><p>Nothing crashes.</p><p>No alarms go off.</p><p>Predictions simply become worse.</p><p>That’s arguably harder to spot than a traditional application failure.</p><h3>SageMaker and MLOps</h3><p>This is where SageMaker starts becoming interesting.</p><p>AWS provides tools for:</p><ul><li>Training models</li><li>Managing model versions</li><li>Deploying endpoints</li><li>Monitoring performance</li><li>Tracking experiments</li></ul><p>You can build much of this yourself, but having managed services available saves a lot of effort.</p><p>For organisations running dozens or hundreds of models, having a consistent process becomes incredibly important.</p><h3>My Take So Far</h3><p>The more I read about MLOps, the more it reminds me of lessons we’ve already learned in software development.</p><p>People don’t struggle because they can’t train a model.</p><p>They struggle because they can’t reliably reproduce what they did six months ago.</p><p>Good MLOps is really about creating repeatable processes.</p><p>Knowing what was deployed.</p><p>Knowing why it was deployed.</p><p>Knowing when it’s no longer performing as expected.</p><p>I’m still very much learning this area, but it’s becoming clear that building the model is only part of the job.</p><p>Keeping it useful is where the real work begins.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffa01ed41d4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>