<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: David Buchan</title>
    <description>The latest articles on DEV Community by David Buchan (@reaver1000).</description>
    <link>https://dev.to/reaver1000</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4172130%2F726d100c-7890-44f5-a024-40c59d9002b2.png</url>
      <title>DEV Community: David Buchan</title>
      <link>https://dev.to/reaver1000</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/reaver1000"/>
    <language>en</language>
    <item>
      <title>I built one job-market dashboard in Tableau and Power BI to learn both properly</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Wed, 18 Nov 2026 11:11:15 +0000</pubDate>
      <link>https://dev.to/reaver1000/i-built-one-job-market-dashboard-in-tableau-and-power-bi-to-learn-both-properly-217k</link>
      <guid>https://dev.to/reaver1000/i-built-one-job-market-dashboard-in-tableau-and-power-bi-to-learn-both-properly-217k</guid>
      <description>&lt;p&gt;My job discovery pipeline (&lt;a href="https://github.com/Reaver1000/remote-job-engine" rel="noopener noreferrer"&gt;remote-job-engine&lt;/a&gt;) sweeps dozens of ATS boards and aggregators every day. Until recently its output was a CSV I opened in a text editor, which is fine when you are hunting for one job and useless when you want to see the shape of the whole market.&lt;/p&gt;

&lt;p&gt;So on 17 November I froze one sweep: &lt;a href="https://github.com/Reaver1000/job-market-dashboard" rel="noopener noreferrer"&gt;15,516 live postings&lt;/a&gt; from 73 sources, covering 1,638 distinct companies and board slugs. Then I built the same dashboard twice, once in Tableau Public and once in Power BI, because that is the fastest honest way to learn where the two tools actually differ instead of guessing from feature lists.&lt;/p&gt;

&lt;h2&gt;
  
  
  The dataset
&lt;/h2&gt;

&lt;p&gt;One flat table. Columns: title, company, location, remote, posted, source, url. No joins, no star schema, which is the point. A BI demo is not impressive because the modelling is exotic, it is impressive because the numbers survive scrutiny.&lt;/p&gt;

&lt;p&gt;The pipeline tags &lt;code&gt;remote&lt;/code&gt; when the location or title signals remote work. On this snapshot that is 2,086 of 15,516 rows. Titles containing junior, graduate or entry account for 362. Those are the figures I would defend: they come straight from the CSV that ships in the repo, not from a screenshot I describe.&lt;/p&gt;

&lt;h2&gt;
  
  
  Building the same thing twice
&lt;/h2&gt;

&lt;p&gt;In Tableau Public the four sheets are roles by source, top companies, roles over time, and a large remote-share number. In Power BI the same four visuals sit behind measures written in DAX: total roles, remote roles, remote share, distinct companies, distinct sources, plus junior roles and a "roles with date" measure.&lt;/p&gt;

&lt;p&gt;Two things stayed with me.&lt;/p&gt;

&lt;p&gt;First, the measure definitions are the product. A bar chart of roles by source is three lines in either tool. Deciding that remote share is &lt;code&gt;SUM(remote) / COUNT(*)&lt;/code&gt; and then checking that the denominator counts rows rather than non-blank cells is where the correctness lives. I committed both definitions (the Tableau calculated fields and &lt;code&gt;measures.dax&lt;/code&gt;) so a reviewer can inspect them rather than take my word.&lt;/p&gt;

&lt;p&gt;Second, the tool differences show up at the edges rather than the core. Both swallowed a 15,000-row CSV in seconds. Tableau's calculated-field syntax feels closer to a spreadsheet; DAX forced me to be explicit about row context and filter context. Neither was harder. They are differently opinionated, and I would choose based on what the team already runs.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the data actually said
&lt;/h2&gt;

&lt;p&gt;The uncomfortable part is worth more than the dashboard. Only 5 of the 15,516 postings matched both remote and an explicitly junior, graduate or entry title. I had been running a job-hunting pipeline for months, and the snapshot made the scarcity visible in one glance: the market is not full of openly junior remote roles, it is full of senior ones. That reframed how I read every posting afterwards.&lt;/p&gt;

&lt;p&gt;A dashboard that makes you update a belief is doing its job. One that only confirms what you already thought is decoration.&lt;/p&gt;

&lt;h2&gt;
  
  
  Known limits
&lt;/h2&gt;

&lt;p&gt;Two, both honest. The &lt;code&gt;posted&lt;/code&gt; column came back empty in this snapshot, so the time-trend sheet has nothing to plot until the pipeline starts capturing dates. And the junior signal is keyword-based, so it misses phrasing like "early careers" or "first role". I left both visible rather than hiding them, because a report that admits its own gaps is easier to trust than one that looks finished.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where this sits
&lt;/h2&gt;

&lt;p&gt;The pipeline finds my shortlist. This dashboard turns one day of its output into evidence that I can model data, define measures, and ship a report in two mainstream BI tools. For a junior data analyst application that is the difference between telling someone you use Tableau and handing them a workbook they can open.&lt;/p&gt;

&lt;p&gt;Repo: &lt;a href="https://github.com/Reaver1000/job-market-dashboard" rel="noopener noreferrer"&gt;https://github.com/Reaver1000/job-market-dashboard&lt;/a&gt;&lt;/p&gt;

</description>
      <category>tableau</category>
      <category>powerbi</category>
      <category>businessintelligence</category>
      <category>dataanalysis</category>
    </item>
    <item>
      <title>My email client runs my first ML classifier. It trains itself from my own keystrokes.</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Mon, 16 Nov 2026 09:44:31 +0000</pubDate>
      <link>https://dev.to/reaver1000/my-email-client-runs-my-first-ml-classifier-it-trains-itself-from-my-own-keystrokes-30ki</link>
      <guid>https://dev.to/reaver1000/my-email-client-runs-my-first-ml-classifier-it-trains-itself-from-my-own-keystrokes-30ki</guid>
      <description>&lt;p&gt;Before I had any professional software title, I built the tool I actually needed: something that triages my inbox before I open it. &lt;a href="https://github.com/Reaver1000/Ai-Email-summariser" rel="noopener noreferrer"&gt;Ai-Email-summariser&lt;/a&gt; connects to Gmail over OAuth2 (or any IMAP server as a fallback), classifies each email as important or junk, labels them accordingly, and uses GPT-3.5-turbo to write a short summary of the ones I open.&lt;/p&gt;

&lt;p&gt;The design decision I keep getting asked about in interviews is why the classifier is TF-IDF plus Random Forest instead of an LLM. The honest answer has three parts, and the third one is the interesting one.&lt;/p&gt;

&lt;h2&gt;
  
  
  The LLM is the expensive part, so it only does one job
&lt;/h2&gt;

&lt;p&gt;Summarisation genuinely needs a language model. Classification does not. An API call to decide "is this junk" costs money, adds latency, and fails at a different level than local code fails. The classifier runs locally with scikit-learn, so triage is free, instant, and works offline. GPT-3.5-turbo only gets called when I actually open an email to read it. Splitting the two jobs meant one API call per email I read instead of one per email that exists.&lt;/p&gt;

&lt;h2&gt;
  
  
  The classifier design, stated plainly
&lt;/h2&gt;

&lt;p&gt;The vectoriser is TF-IDF with a 5000-feature cap, English stop words removed, and unigrams plus bigrams. The classifier is a Random Forest with 100 estimators and &lt;code&gt;class_weight='balanced'&lt;/code&gt;, which matters because my real inbox is not 50/50: the junk-heavy reality would otherwise let a model score well by predicting "junk" constantly.&lt;/p&gt;

&lt;p&gt;The input features are deliberately crude: subject, sender, and body concatenated into one string. No fancy sender-reputation graph, no header analysis. I wanted the first version to be auditable, and with TF-IDF I can print which words pushed a classification either way. That turned out to matter for trust: when the model flags something important that I thought was junk, being able to see why makes me fix my assumptions instead of distrusting the tool.&lt;/p&gt;

&lt;h2&gt;
  
  
  The cold-start problem is a UX problem
&lt;/h2&gt;

&lt;p&gt;An untrained classifier is useless, and a tool that demands training data before it works is a tool nobody sets up. So the first prediction on any fresh install returns a neutral 0.5/0.5 with the label defaulting to important, and the interface shows that confidence number next to every email. You are never asked to trust the model. You are asked to correct it.&lt;/p&gt;

&lt;p&gt;Every correction (&lt;code&gt;i1&lt;/code&gt; marks email one important, &lt;code&gt;j2&lt;/code&gt; marks two junk) goes into a JSON feedback file that deduplicates by a composite id built from the subject, sender, and a hash of the body preview, so marking the same email twice updates the label instead of duplicating the training row. Each retrain happens on demand from that file, milliseconds, on my machine. The model persists to a joblib file and reloads on the next run.&lt;/p&gt;

&lt;p&gt;This is the part I would defend hardest in a design review: the feedback loop is the product. The model itself is the boring part, a textbook scikit-learn pipeline, and that is fine. What makes the tool usable by week two is that it becomes &lt;em&gt;mine&lt;/em&gt; by week two, trained on what I personally consider junk.&lt;/p&gt;

&lt;h2&gt;
  
  
  The tests
&lt;/h2&gt;

&lt;p&gt;Eight tests in unittest with mocked Gmail responses: prediction structure, the train-and-persist path, feedback deduplication (adding the same email twice updates one row and flips the label), the Gmail integration with a mocked service, and three edge cases that taught me the most. An empty email, a 10,000-character body, and a body full of special characters including multi-script text all have to return a valid prediction structure rather than an exception, because the alternative is the classifier crashing on the one weird email that matters most.&lt;/p&gt;

&lt;p&gt;The duplicate-feedback test is the one I would keep if I could keep only one. It encodes the assumption that feedback should correct, not accumulate, which is exactly the bug that would silently poison the training data if someone refactored the feedback manager later.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I would change
&lt;/h2&gt;

&lt;p&gt;Two things, both known. First, the neutral fallback on prediction failure is silent; it should log so I can see how often the vectoriser is being fed garbage. Second, there is no evaluation set at all, because the feedback file doubles as training data. The moment the feedback pool gets large enough, I want a held-out split so accuracy is measured instead of felt.&lt;/p&gt;

&lt;p&gt;The stack is Python with scikit-learn, the Gmail API with IMAP fallback, OpenAI for summaries only, and unittest with mocks. Nothing exotic, and that is the point: this is what a first production-shaped ML system looks like when the goal is a tool you run every day rather than a benchmark score.&lt;/p&gt;

&lt;p&gt;Full repo: &lt;a href="https://github.com/Reaver1000/Ai-Email-summariser" rel="noopener noreferrer"&gt;https://github.com/Reaver1000/Ai-Email-summariser&lt;/a&gt;&lt;/p&gt;

</description>
      <category>machinelearning</category>
      <category>python</category>
      <category>scikitlearn</category>
      <category>openai</category>
    </item>
    <item>
      <title>I wrote four file tools and made sure every destructive path is defensive</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Wed, 11 Nov 2026 11:32:00 +0000</pubDate>
      <link>https://dev.to/reaver1000/i-wrote-four-file-tools-and-made-sure-every-destructive-path-is-defensive-165i</link>
      <guid>https://dev.to/reaver1000/i-wrote-four-file-tools-and-made-sure-every-destructive-path-is-defensive-165i</guid>
      <description>&lt;p&gt;I spent five years in banking operations before writing software for a living, and the reason this tool exists is muscle memory from that time: someone asks for the files to be tidied, deduplicated, backed up or triaged, and the person who volunteers learns very quickly that most file scripts are only one careless flag away from deleting the wrong thing.&lt;/p&gt;

&lt;p&gt;So I built &lt;a href="https://github.com/Reaver1000/python-automation-toolkit" rel="noopener noreferrer"&gt;python-automation-toolkit&lt;/a&gt; as four tools behind one CLI, standard library only, with the safety behaviour written as features and then pinned in place by tests. Twenty of them, all running against pytest &lt;code&gt;tmp_path&lt;/code&gt; sandboxes, so the test suite itself never touches a real file.&lt;/p&gt;

&lt;h2&gt;
  
  
  The four tools
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;organize&lt;/code&gt; sorts a folder into subfolders by extension or modification month. &lt;code&gt;duplicates&lt;/code&gt; finds byte-identical files and optionally removes them. &lt;code&gt;backup&lt;/code&gt; creates timestamped zip archives with rotation and restores them. &lt;code&gt;logs&lt;/code&gt; pulls ERROR and CRITICAL lines out of a log, counts entries per level, or greps a regex.&lt;/p&gt;

&lt;p&gt;None of that is clever. What is worth writing down is where each one was deliberately made hard to misuse.&lt;/p&gt;

&lt;h2&gt;
  
  
  Collisions create copies, not casualties
&lt;/h2&gt;

&lt;p&gt;When &lt;code&gt;organize&lt;/code&gt; moves a file into a destination that already contains that name, it does not overwrite. The destination path gets a suffix (&lt;code&gt;report.pdf&lt;/code&gt; becomes &lt;code&gt;report_1.pdf&lt;/code&gt;) and the move proceeds. I could have made the tool error instead, but a bulk sort job that aborts on the first collision teaches people to run it with a flag they found on a forum. Copying is the boring behaviour that is safe by default, and the tool can be run into a non-empty destination without reading a manual first.&lt;/p&gt;

&lt;h2&gt;
  
  
  Duplicate detection is two-phase on purpose
&lt;/h2&gt;

&lt;p&gt;Byte-identical detection hashes every file with SHA-256, but only after a size pre-filter. Files are grouped by size first and only candidates in the same size group get hashed. On any realistic folder, sizes differ far more often than contents do, so the expensive part runs on a small subset. The block size for hashing is 64KB rather than whole-file reads, which keeps memory flat on large media files.&lt;/p&gt;

&lt;p&gt;On the hash choice: MD5 would have been fine for "same bytes" detection in practice, but the tool's next step after a match is deletion, and I did not want the question "what if two different files collide on the digest" to live in the back of my head. SHA-256 closes it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The destructive path asks to be watched
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;duplicates --remove&lt;/code&gt; will not run a silent pass. You can preview with &lt;code&gt;--dry-run&lt;/code&gt;, which prints exactly what the real run would delete, line for line, and you choose what survives: the alphabetically first copy or the newest modification time (&lt;code&gt;--keep newest&lt;/code&gt;). Invalid options fail loudly with an error rather than falling back to some default that deletes more than you asked.&lt;/p&gt;

&lt;p&gt;That pattern repeated itself: &lt;code&gt;backup create&lt;/code&gt; writes a fresh timestamped zip and rotation keeps only the newest N (&lt;code&gt;--rotate 7&lt;/code&gt; for a nightly rhythm); anything beyond that gets deleted, which is itself destructive, so rotation happens on an explicit flag rather than being baked into every create.&lt;/p&gt;

&lt;h2&gt;
  
  
  Determinism is a feature you can test
&lt;/h2&gt;

&lt;p&gt;Archive members are written in sorted order, so two backups of an unchanged tree are byte-comparable. That sounds like a detail until you want to write a test that says "the backup contains exactly these files in exactly this order", which is one of the twenty. Sorting also means a diff between two backup zips tells you what changed in the source, which is a genuinely useful property I did not plan for.&lt;/p&gt;

&lt;h2&gt;
  
  
  The tests
&lt;/h2&gt;

&lt;p&gt;The 20 tests cover three families: happy paths, safety behaviours (collision handling, dry-run preview, last-copy survival in a duplicate set), and failure modes (missing archive, invalid options). Everything runs in &lt;code&gt;tmp_path&lt;/code&gt; sandboxes. The failure-mode tests are the ones I would keep even if I had to cut the suite down, because they are what stops a future refactor from quietly turning an error into a silent destructive fallback.&lt;/p&gt;

&lt;p&gt;The CLI is 331 lines of Python with no dependencies. &lt;code&gt;pytest&lt;/code&gt; is the only dev requirement. If that sounds too small, consider that most people who have lost files to a script lost them to something smaller.&lt;/p&gt;

&lt;p&gt;Full repo: &lt;a href="https://github.com/Reaver1000/python-automation-toolkit" rel="noopener noreferrer"&gt;https://github.com/Reaver1000/python-automation-toolkit&lt;/a&gt;&lt;/p&gt;

</description>
      <category>python</category>
      <category>automation</category>
      <category>testing</category>
      <category>cli</category>
    </item>
    <item>
      <title>My README claimed 50 SQL templates and shipped 8. Now the tests enforce the claim.</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Mon, 09 Nov 2026 11:55:17 +0000</pubDate>
      <link>https://dev.to/reaver1000/my-readme-claimed-50-sql-templates-and-shipped-8-now-the-tests-enforce-the-claim-11cc</link>
      <guid>https://dev.to/reaver1000/my-readme-claimed-50-sql-templates-and-shipped-8-now-the-tests-enforce-the-claim-11cc</guid>
      <description>&lt;p&gt;Open the README above a small SQL library and you will see numbers. I have written those numbers myself, and this is the story of the one that was wrong.&lt;/p&gt;

&lt;p&gt;My SQL playground repo started with a README that claimed "50+ query templates". The actual count was 8. I did not lie on purpose. The number drifted the way most README drift happens: I wrote the line while planning the library, shipped a fraction of it, and then stopped looking at the gap.&lt;/p&gt;

&lt;p&gt;The fix was not writing 50 more templates. The fix was making the claim impossible to break.&lt;/p&gt;

&lt;h2&gt;
  
  
  The structural fix
&lt;/h2&gt;

&lt;p&gt;The whole template library lives in two data files, &lt;code&gt;templates.py&lt;/code&gt; and &lt;code&gt;templates_advanced.py&lt;/code&gt;. The Streamlit app renders whatever is in the library. The tests import the same files. One source of truth, two consumers.&lt;/p&gt;

&lt;p&gt;Then &lt;code&gt;tests/test_templates.py&lt;/code&gt; runs the entire library through pytest with parametrization, currently 115 tests, and each template fails CI if any of these happen:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The query errors against the sample database.&lt;/li&gt;
&lt;li&gt;It runs but returns zero rows, which usually means a broken join or a filter that filters everything.&lt;/li&gt;
&lt;li&gt;The total count drops below 50, which turns the README claim into something the CI pipeline enforces instead of something I have to remember.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The last one is the odd-looking test, and it is the one I would defend hardest. A test that asserts your library is large enough for your own documentation sounds like a stunt, but it is the same logic as a smoke test on an API: the promise either holds at a fixed threshold or it doesn't, and a number explicitly written in public deserves a guard.&lt;/p&gt;

&lt;h2&gt;
  
  
  The sample database makes honesty cheap
&lt;/h2&gt;

&lt;p&gt;All of this works because the sample data is deterministic. Seeded RNG in &lt;code&gt;sample_data.py&lt;/code&gt; generates an in-memory e-commerce schema in DuckDB, 4 tables and roughly 19k rows, identical on every run. A parametrized test suite over 55 templates can only be trusted if the ground under it never moves.&lt;/p&gt;

&lt;p&gt;That was also why I picked DuckDB over SQLite for this project. The library teaches things SQLite cannot express: &lt;code&gt;QUALIFY&lt;/code&gt;, &lt;code&gt;FILTER (WHERE ...)&lt;/code&gt;, &lt;code&gt;ROLLUP&lt;/code&gt;, &lt;code&gt;PERCENTILE_CONT&lt;/code&gt;, and &lt;code&gt;generate_series&lt;/code&gt; for date spines. Recreating those in SQLite would have meant rewriting the lessons or teaching a dialect that keeps the boring half of the topic.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the categories look like
&lt;/h2&gt;

&lt;p&gt;The 55 templates are grouped by what they teach rather than by SQL keyword.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Basics and filtering: 12 templates covering computed columns and anti-joins with &lt;code&gt;NOT EXISTS&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Joins: 7 templates, including a self-join and the filter-in-the-&lt;code&gt;ON&lt;/code&gt; semantic that trips people up constantly.&lt;/li&gt;
&lt;li&gt;Aggregation and window functions: 15 templates covering &lt;code&gt;ROLLUP&lt;/code&gt; subtotals, percentiles, &lt;code&gt;NTILE&lt;/code&gt; buckets, and running totals.&lt;/li&gt;
&lt;li&gt;Date and time: 6 templates including signup-to-first-order gaps.&lt;/li&gt;
&lt;li&gt;CTEs and subqueries: 6 templates with multi-CTE funnels and a recursive month spine.&lt;/li&gt;
&lt;li&gt;Business analytics: 9 templates that stack into Pareto 80/20, RFM scoring, cohort retention, and market basket analysis.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You can run the whole thing without installing anything: DuckDB compiles to WebAssembly, so the &lt;a href="https://reaver1000-sql-query-playground.static.hf.space" rel="noopener noreferrer"&gt;Hugging Face demo&lt;/a&gt; runs the real engine in the browser, and the same code is on &lt;a href="https://sql-query-builder-uzsrs2gl2af8avqsxappchw.streamlit.app" rel="noopener noreferrer"&gt;Streamlit Cloud&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I would tell a junior writing a portfolio repo
&lt;/h2&gt;

&lt;p&gt;Pick one number you want to be known for and make it a test. Mine turned out to be the template count. It could be a major version of your pipeline throughput, a latency budget, or a coverage floor. When the claim and the code are wired together, updating one without the other stops being possible, and a README bullet becomes a contract instead of a wish.&lt;/p&gt;

&lt;p&gt;Full repo: &lt;a href="https://github.com/Reaver1000/sql-query-builder" rel="noopener noreferrer"&gt;https://github.com/Reaver1000/sql-query-builder&lt;/a&gt;&lt;/p&gt;

</description>
      <category>sql</category>
      <category>testing</category>
      <category>python</category>
      <category>devops</category>
    </item>
    <item>
      <title>How I built a reproducible SQL and pandas pipeline from raw data to executive summary</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Fri, 06 Nov 2026 17:35:10 +0000</pubDate>
      <link>https://dev.to/reaver1000/how-i-built-a-reproducible-sql-and-pandas-pipeline-from-raw-data-to-executive-summary-1d8l</link>
      <guid>https://dev.to/reaver1000/how-i-built-a-reproducible-sql-and-pandas-pipeline-from-raw-data-to-executive-summary-1d8l</guid>
      <description>&lt;p&gt;Most data analysis demos stop at the SQL. There is a nice query, a table of results, and then a gap where the actual deliverable should be. I wanted the whole path in one place: load the data, run the queries, chart the results, and produce a report a non-technical person could actually read.&lt;/p&gt;

&lt;p&gt;So I built &lt;a href="https://github.com/Reaver1000/data-analysis-demo" rel="noopener noreferrer"&gt;data-analysis-demo&lt;/a&gt; around exactly that path.&lt;/p&gt;

&lt;h2&gt;
  
  
  The data
&lt;/h2&gt;

&lt;p&gt;To keep the repo self-contained, the dataset is generated in Python. 200 customers, 50 products, and 1,000 orders, with order statuses split roughly 70% Completed, 20% Shipped, 10% Processing, all loaded into SQLite with &lt;code&gt;pandas.to_sql&lt;/code&gt;. A &lt;code&gt;--data&lt;/code&gt; flag accepts a CSV if you want to bring your own.&lt;/p&gt;

&lt;p&gt;I put the fact that it is synthetic in the README, up front. The revenue numbers themselves mean nothing. What the project demonstrates is the pipeline, and that anyone can clone it, run one command, and get the same shape of output.&lt;/p&gt;

&lt;h2&gt;
  
  
  Four analyses, one function each
&lt;/h2&gt;

&lt;p&gt;Each analysis is a single function: a SQL query through &lt;code&gt;pd.read_sql&lt;/code&gt;, then a chart saved to disk, then the DataFrame returned to the caller.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Revenue by category. A three-way join over orders, order_items and products, grouped by category, drawn as a labelled horizontal bar chart.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Customer lifetime value. A CTE computes per-customer order counts and lifetime spend with a LEFT JOIN, so customers with zero orders still survive the join, then groups the result by segment.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Monthly trends. &lt;code&gt;strftime('%Y-%m', order_date)&lt;/code&gt; buckets orders by month, plotted as revenue on one axis and order count on a twin axis.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Product affinity. Pairs of products bought together, counted with a self-join.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The affinity query was the one I got wrong first. It joins &lt;code&gt;order_items&lt;/code&gt; against itself on the same order, and without a condition the pair (A, B) gets counted twice, once as A+B and once as B+A. Adding &lt;code&gt;oi1.product_id &amp;lt; oi2.product_id&lt;/code&gt; keeps one canonical direction per pair. One character fixes the entire metric.&lt;/p&gt;

&lt;h2&gt;
  
  
  The report is generated, not written
&lt;/h2&gt;

&lt;p&gt;The executive summary in &lt;code&gt;reports/executive_summary.md&lt;/code&gt; is built from the DataFrames, not from me. Top three categories by revenue, average LTV per segment, the peak revenue month found with &lt;code&gt;idxmax&lt;/code&gt;, and the top five affinity pairs. If the data changes, the report changes with it, which is the honest way to write a summary script. Hardcoding the conclusions would have been easier and would have made the whole thing a sticker.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the pipeline looks like
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Every analysis function returns a DataFrame. The report generator just formats whatever it is handed.&lt;/li&gt;
&lt;li&gt;The SQL and its chart live in the same function, so a broken query is visible immediately instead of failing politely downstream.&lt;/li&gt;
&lt;li&gt;Queries are strings in &lt;code&gt;analyze.py&lt;/code&gt; for now. The README documents the extension pattern of moving them into &lt;code&gt;queries/&lt;/code&gt; files, and the next version of the script will do that, including the NTILE quartile and cohort retention queries the README already shows.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Running it is two commands: &lt;code&gt;pip install pandas matplotlib&lt;/code&gt;, then &lt;code&gt;python analyze.py&lt;/code&gt;. It writes the charts and the report and prints the tables as it goes.&lt;/p&gt;

&lt;p&gt;Full repo: &lt;a href="https://github.com/Reaver1000/data-analysis-demo" rel="noopener noreferrer"&gt;https://github.com/Reaver1000/data-analysis-demo&lt;/a&gt;&lt;/p&gt;

</description>
      <category>sql</category>
      <category>python</category>
      <category>dataanalysis</category>
      <category>pandas</category>
    </item>
    <item>
      <title>How I built a CI-safe eval harness for structured LLM output</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Fri, 30 Oct 2026 14:09:41 +0000</pubDate>
      <link>https://dev.to/reaver1000/how-i-built-a-ci-safe-eval-harness-for-structured-llm-output-5d21</link>
      <guid>https://dev.to/reaver1000/how-i-built-a-ci-safe-eval-harness-for-structured-llm-output-5d21</guid>
      <description>&lt;p&gt;Most teams evaluate LLMs by reading a few outputs and nodding. That works until it doesn't.&lt;/p&gt;

&lt;p&gt;I built &lt;code&gt;llm-contract&lt;/code&gt; because I needed my own pipeline to be honest about whether a change actually made things better.&lt;/p&gt;

&lt;p&gt;The contract has three parts:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Schema-first extraction.&lt;/strong&gt; Every LLM call returns JSON against a fixed schema. If the model drifts, the pipeline fails fast instead of silently producing garbage.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Validation feedback retries.&lt;/strong&gt; When the schema check fails, the error goes back to the model with the exact violation. It gets one retry. Most of the time it fixes itself; the rest get flagged for human review.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;A CI-safe eval harness.&lt;/strong&gt; Recorded case files (input, expected output, metadata) run in pytest. No API calls during the test run. Everything is replayed from recordings. A change to the prompt or the model is a commit that either passes the full suite or it doesn't merge.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The lesson that took me the longest: how you split your data matters more than your model.&lt;/p&gt;

&lt;p&gt;I used to take a random 80/20 split. For time-stamped or session-based data, that leaks adjacent frames into training and makes your eval look perfect while production fails. Holding out whole sessions is the honest split. Temporal validation usually drops your measured accuracy by enough to be uncomfortable. That discomfort is the point.&lt;/p&gt;

&lt;p&gt;Weights published without raw data. Metrics published without prose. Code with tests. That's the pattern I'm standardizing on.&lt;/p&gt;

&lt;p&gt;Full repo: &lt;a href="https://github.com/Reaver1000/llm-contract" rel="noopener noreferrer"&gt;https://github.com/Reaver1000/llm-contract&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>llm</category>
      <category>python</category>
    </item>
    <item>
      <title>Fine-tuning a YOLO26 classifier on trading-livestream screen captures - with a Whisper + VLM labeling flywheel</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Tue, 27 Oct 2026 08:07:50 +0000</pubDate>
      <link>https://dev.to/reaver1000/fine-tuning-a-yolo26-classifier-on-trading-livestream-screen-captures-with-a-whisper-vlm-5d7g</link>
      <guid>https://dev.to/reaver1000/fine-tuning-a-yolo26-classifier-on-trading-livestream-screen-captures-with-a-whisper-vlm-5d7g</guid>
      <description>&lt;p&gt;Most computer-vision demos start with a dataset someone else curated. Mine started with screen recordings I was not allowed to redistribute - which turned out to be the most instructive constraint in the whole project.&lt;/p&gt;

&lt;p&gt;This is the story of &lt;code&gt;trade-state-classifier&lt;/code&gt;: a fine-tuned YOLO26n-cls model that looks at a screenshot from a trading livestream and answers one binary question - &lt;strong&gt;is there a filled position visible on screen right now?&lt;/strong&gt; - plus the labeling pipeline that made it possible without anybody's data leaving my machine.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why binary classification (and not object detection)
&lt;/h2&gt;

&lt;p&gt;The upstream goal is an event pipeline: watch a livestream, detect the moment a streamer's position state changes (flat -&amp;gt; open -&amp;gt; flat), extract the displayed entry/stop/target levels at that moment, and hand a validated event to the execution layer.&lt;/p&gt;

&lt;p&gt;Full UI-element detection (order tickets, entry lines, price badges) is the endgame - but it needs far more labeled variety than I could curate responsibly. A state gate needs to answer exactly one question reliably. So v1 = one classifier, one binary decision, measured hard.&lt;/p&gt;

&lt;h2&gt;
  
  
  The labeling problem
&lt;/h2&gt;

&lt;p&gt;Fine-tuning means labels, and labels for this task have a nasty property: &lt;strong&gt;open position is rare&lt;/strong&gt;. Uniform frame sampling at 1 fps gives you thousands of near-identical flat-screen frames and a handful of meaningful ones. Label quality would drown.&lt;/p&gt;

&lt;p&gt;The flywheel that solved it:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Whisper (faster-whisper, local) transcribes the VOD.&lt;/strong&gt; Talking traders narrate what they are doing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Speech-cue parser finds candidate windows&lt;/strong&gt; - phrases around "getting filled", "taking profit", "stopped out", "flat now".&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sparse frame extraction&lt;/strong&gt; - only the seconds around each cue, not the whole hour. Roughly two orders of magnitude fewer frames to look at.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Local VLM (qwen2.5vl:7b via Ollama) drafts labels&lt;/strong&gt; for those keyframes, based on an element list (position badge, PnL overlay, position box).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Confluence confirmation&lt;/strong&gt; - a window only survives if speech and vision agree. The two chatterboxes must contradict each other to flag a frame for me.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Owner-verified dense segments&lt;/strong&gt; around confirmed trade windows - I confirm every frame in the segments I train on.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That last step matters. VLMs fast-draft; they do not carry truth. Every training frame was verified by the only model with skin in the game: me.&lt;/p&gt;

&lt;h2&gt;
  
  
  The training run
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Base: YOLO26n-cls (Ultralytics), the nano variant, deliberately - CPU inference at ~15ms/frame keeps the state gate cheap enough to run continuously.&lt;/li&gt;
&lt;li&gt;Input: ~1,700 confluence-confirmed crops, 512x512.&lt;/li&gt;
&lt;li&gt;20 epochs, batch 16.&lt;/li&gt;
&lt;li&gt;Evaluation: &lt;strong&gt;temporal validation&lt;/strong&gt; - sessions the model never saw during training. Adjacent frames leak; a random frame-split lies to you. Holding out entire sessions is the honest split.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Result table (iterations v11 -&amp;gt; v17):&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Milestone&lt;/th&gt;
&lt;th&gt;What changed&lt;/th&gt;
&lt;th&gt;Held-out result&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;v11&lt;/td&gt;
&lt;td&gt;context-menu and hypothetical position drawings mined out as hard negatives&lt;/td&gt;
&lt;td&gt;100% (341/341), 0 false opens&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;v13&lt;/td&gt;
&lt;td&gt;dense confluence windows per confirmed trade&lt;/td&gt;
&lt;td&gt;100%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;v16&lt;/td&gt;
&lt;td&gt;five more sessions pooled&lt;/td&gt;
&lt;td&gt;100% (341/341), 0/165 false positives&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The interesting run: a session whose only state was "no trades, all day" produced ten 1-second VLM "open" blips taught nothing - until dense windows around the one confirmed trade window were added. Sparse VLM labels had a blind spot; the fix was density, not cleverness.&lt;/p&gt;

&lt;h2&gt;
  
  
  The publishing decision that took longer than the training
&lt;/h2&gt;

&lt;p&gt;After validation the question was: what can go public?&lt;/p&gt;

&lt;p&gt;The model can. The frames cannot - they are someone else's screen, and I decided redistribution crosses a line I did not want to argue with anyone about.&lt;/p&gt;

&lt;p&gt;So: weights on the Hugging Face hub, zero images anywhere, no channel names, no video IDs. Then a full audit of my own public repos - because the training story &lt;em&gt;lives&lt;/em&gt; in commit history, docstrings, and example paths. Every identifier got generalized (channel-a/channel-b, session placeholders), the harness scripts removed those, and history was rewritten rather than patched so nothing was merely invisible-but-recoverable.&lt;/p&gt;

&lt;p&gt;A "publish without exposure" checklist that I now treat as standard:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Weights are fine, frames are not.&lt;/li&gt;
&lt;li&gt;Descriptive metrics OK; provenance narratives are leaks.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git log&lt;/code&gt;, example paths, and docstrings are part of your public surface - audit them, not just README.md.&lt;/li&gt;
&lt;li&gt;If exposure retrofitting needs three layers (working tree, history, hub), treat that cost as the price of skipping hygiene in the first place.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What the classifier still cannot do
&lt;/h2&gt;

&lt;p&gt;Saying this publicly protects future-me:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;It detects a &lt;em&gt;visible&lt;/em&gt; position badge - a streamer chart-hopping mid-trade looks like flat.&lt;/li&gt;
&lt;li&gt;It is platform-appearance-specific. A position box on one platform does not look like another's; pooled training helps, new platforms will need new data.&lt;/li&gt;
&lt;li&gt;A drawn (hypothetical) position-tool box and a filled position can look identical. The visual gate alone cannot tell you a fill happened - that is why the upstream pipeline requires speech confluence and state-transition logic.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  What is next
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;ONNX export and an in-browser demo: the whole model running in the visitor's browser via onnxruntime-web, on screenshots the visitor brings (privacy-compatible demo by construction).&lt;/li&gt;
&lt;li&gt;More platform calibrations, pooled rather than forked.&lt;/li&gt;
&lt;li&gt;The universal detector: entry/stop/target/quantity reads off any chart, with OCR and geometric validation deciding whether an event is even possible.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The full labeled pipeline, validation tooling and inference scripts are in the &lt;a href="https://github.com/Reaver1000/stream-signal-vision" rel="noopener noreferrer"&gt;stream-signal-vision repository&lt;/a&gt;, and the published weights are at &lt;a href="https://huggingface.co/Reaver1000/trade-state-classifier" rel="noopener noreferrer"&gt;trade-state-classifier on Hugging Face&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>computervision</category>
      <category>python</category>
    </item>
    <item>
      <title>Practical patterns for LLM scoring in n8n workflows</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Wed, 21 Oct 2026 10:18:49 +0000</pubDate>
      <link>https://dev.to/reaver1000/practical-patterns-for-llm-scoring-in-n8n-workflows-2aag</link>
      <guid>https://dev.to/reaver1000/practical-patterns-for-llm-scoring-in-n8n-workflows-2aag</guid>
      <description>&lt;p&gt;My n8n workflows follow one hard rule, learned the hard way: rules are cheap, deterministic, and auditable, so they run first. Language models are none of those things, so they run second, on the small population of cases where rules thrash. Lead qualification is the classic example. Company size, email domain, seniority — a lookup table handles those. "Is this inbound request actually a fit for what we sell?" — that is where the rule-based version of me wrote forty brittle IF nodes and lost.&lt;/p&gt;

&lt;p&gt;Here are the five patterns I use when adding LLM scoring to a workflow. They are the same principles behind my job-search pipeline, scaled down to node size.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pattern 1: demand structured output, not prose
&lt;/h2&gt;

&lt;p&gt;Never let the model write you a paragraph you then parse with string matching. Most LLM nodes in n8n (and raw API calls via the HTTP node) support a JSON response format. Ask for exactly this shape and nothing else:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"score"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;0-100&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"verdict"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"sales"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="err"&gt;|&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"nurture"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="err"&gt;|&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"reject"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"reasons"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"one line each"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Temperature 0. A schema the model cannot deviate from. Prose is for humans; pipelines eat JSON.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pattern 2: the model scores, the rules route
&lt;/h2&gt;

&lt;p&gt;Put the scoring step behind your existing rule chain, and put an IF node after it. The model's &lt;code&gt;verdict&lt;/code&gt; feeds the IF. The model never writes to your CRM, never sends the alert, never decides anything at the edge. It fills a field. Nodes that do things stay deterministic.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pattern 3: every error branch lands on a default
&lt;/h2&gt;

&lt;p&gt;The model will time out, return malformed JSON on a bad day, or rate-limit you during a burst. Every one of those cases must land somewhere sensible: error branch to a &lt;code&gt;Set&lt;/code&gt; node that writes a default score and a &lt;code&gt;reasons: ["model_unavailable"]&lt;/code&gt; flag. The workflow keeps running. This is the n8n version of errors-are-data: a full run report with a few defaulted scores beats a dead pipeline with a perfect one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pattern 4: cheap model, precise prompt
&lt;/h2&gt;

&lt;p&gt;Scoring a lead against a rubric is not frontier-model work. A small, fast, cheap model with a prompt that contains your actual rubric — with examples — beats a big model with a vague prompt. Put the rubric in the prompt: what makes a 90, what makes a 30, what is an instant reject. The money you save buys a lot of retries.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pattern 5: log the reasons, not just the scores
&lt;/h2&gt;

&lt;p&gt;Write score and reasons to your log store every single run. Two weeks later you will find the leads that scored 61 and deserved 90, and the exact sentence in the rubric that caused it. Without logged reasons you have a black box; with them you have a reviewable system. The template library runs 1,892-plus alert cycles at 99.7% for exactly this kind of reason — you cannot fix what you do not log.&lt;/p&gt;

&lt;h2&gt;
  
  
  Status and links
&lt;/h2&gt;

&lt;p&gt;I am applying these to the lead-qualification template in my open-source n8n library, and the job-search engine that taught me these patterns is public too: &lt;a href="https://github.com/Reaver1000/n8n-automation-templates" rel="noopener noreferrer"&gt;n8n-automation-templates&lt;/a&gt; and &lt;a href="https://github.com/Reaver1000/remote-job-engine" rel="noopener noreferrer"&gt;remote-job-engine&lt;/a&gt;. The bigger version of this story — 1,500+ postings scored, rules first, model second — is &lt;a href="https://dev.to/reaver1000/i-built-an-ai-that-finds-and-scores-my-next-job-49je"&gt;here&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;I am a junior automation and data builder, career-changer, fully remote from Germany (or UK). If your team runs n8n or needs LLM integrations that do not hallucinate their way into production: &lt;a href="https://reaver1000.github.io" rel="noopener noreferrer"&gt;reaver1000.github.io&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>automation</category>
      <category>n8n</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Anyone can claim to be an up-and-coming AI engineer. Here are my receipts instead.</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Fri, 16 Oct 2026 08:32:32 +0000</pubDate>
      <link>https://dev.to/reaver1000/anyone-can-claim-to-be-an-up-and-coming-ai-engineer-here-are-my-receipts-instead-4m26</link>
      <guid>https://dev.to/reaver1000/anyone-can-claim-to-be-an-up-and-coming-ai-engineer-here-are-my-receipts-instead-4m26</guid>
      <description>&lt;p&gt;"Up and coming." "Promising." "One to watch." Every job board and every LinkedIn feed is full of people describing themselves with adjectives. I do not want to do that, because adjectives are unverifiable noise. So this post is something else: my first year of building in public, in receipts, with links. Judge the trajectory, not the adjectives.&lt;/p&gt;

&lt;h2&gt;
  
  
  The receipts
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;2022 — the degree, done at night.&lt;/strong&gt; I started a BSc in Computing and IT with the Open University while working full time. I finished it in 2026. Not a receipt for talent — a receipt for stubbornness, which is more reliable anyway.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2025 — n8n templates that run in production.&lt;/strong&gt; I built a set of workflow templates for n8n and put them to work. The alert monitor has run 1,892 times at 99.7% success. Lead qualification: 247 runs, 99.2%. Data sync: 312 runs, 97.8%. They are open source: &lt;a href="https://github.com/Reaver1000/n8n-automation-templates" rel="noopener noreferrer"&gt;n8n-automation-templates&lt;/a&gt;. A template that runs weekly for months without you touching it is worth more than any certificate.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2026 — the job search engine.&lt;/strong&gt; I automated my own job hunt: 30+ ATS boards, deduplication against every posting I have ever seen, hard rule filters before any LLM call, then LLM scoring against my honest profile. Over 1,500 postings evaluated this year; 1,539 parked; 12 apply-worthy. Public and scrubbed: &lt;a href="https://github.com/Reaver1000/remote-job-engine" rel="noopener noreferrer"&gt;remote-job-engine&lt;/a&gt; and &lt;a href="https://github.com/Reaver1000/job-sweep" rel="noopener noreferrer"&gt;job-sweep&lt;/a&gt;. The full story is &lt;a href="https://dev.to/reaver1000/i-built-an-ai-that-finds-and-scores-my-next-job-49je"&gt;on dev.to&lt;/a&gt;, and auf Deutsch too.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;September 2026 — the quality wave.&lt;/strong&gt; One month, four repos, all with tests: a &lt;a href="https://github.com/Reaver1000/etl-data-pipeline" rel="noopener noreferrer"&gt;composable ETL framework&lt;/a&gt; (errors as data, whitelist mapping, CI), a &lt;a href="https://github.com/Reaver1000/sql-query-builder" rel="noopener noreferrer"&gt;SQL playground&lt;/a&gt; (55 templates, 115 tests, now a &lt;a href="https://sql-query-builder-uzsrs2gl2af8avqsxappchw.streamlit.app" rel="noopener noreferrer"&gt;live demo&lt;/a&gt;), a &lt;a href="https://github.com/Reaver1000/python-automation-toolkit" rel="noopener noreferrer"&gt;file automation toolkit&lt;/a&gt; (20 tests), and a &lt;a href="https://github.com/Reaver1000/finance-dashboard" rel="noopener noreferrer"&gt;finance analytics dashboard&lt;/a&gt;. The lesson post is &lt;a href="https://dev.to/reaver1000/errors-are-data-what-building-a-small-etl-framework-taught-me-3mhn"&gt;here&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;October 2026 — the paper trail.&lt;/strong&gt; Three technical articles, a bilingual portfolio site, and a live demo instead of dead links. You are reading the third article.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the receipts have in common
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Build things you actually use.&lt;/strong&gt; My n8n templates monitor services I care about. My job engine found the shortlist I am actually working through. Tools you use daily cannot fake it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tests or it did not happen.&lt;/strong&gt; Every framework repo has a test suite. The SQL playground has 115 tests that execute all 55 templates. This is not rigour for its own sake — it is the difference between "code exists" and "code works."&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Write it down.&lt;/strong&gt; The articles are not marketing. They are the honest lessons, including the ones that cost me: six perfect-looking job candidates that died when I read the actual posting bodies.&lt;/p&gt;

&lt;h2&gt;
  
  
  The honest gap
&lt;/h2&gt;

&lt;p&gt;I have no professional software engineering title yet. Thirteen years in operations — Lloyds Banking Group, Deutsche Post, sysadmin, currently Amazon print production — and a degree, and all the receipts above, and no job title in software. That is the next receipt, and it is the one I cannot publish myself. Someone has to give it to me.&lt;/p&gt;

&lt;p&gt;If your team needs a junior or associate who already works like this — AI, automation, or data, fully remote from Germany or UK — everything is on &lt;a href="https://reaver1000.github.io" rel="noopener noreferrer"&gt;reaver1000.github.io&lt;/a&gt;. The receipts are the résumé. The next one is yours to write.&lt;/p&gt;

</description>
      <category>career</category>
      <category>ai</category>
      <category>data</category>
      <category>beginners</category>
    </item>
    <item>
      <title>Wie ich eine KI gebaut habe, die meine Jobsuche übernimmt</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Sun, 11 Oct 2026 14:01:31 +0000</pubDate>
      <link>https://dev.to/reaver1000/wie-ich-eine-ki-gebaut-habe-die-meine-jobsuche-ubernimmt-4e6i</link>
      <guid>https://dev.to/reaver1000/wie-ich-eine-ki-gebaut-habe-die-meine-jobsuche-ubernimmt-4e6i</guid>
      <description>&lt;p&gt;Jede Woche durchsucht meine Software etwa zwanzig Stellenbörsen. Sie sammelt ein paar hundert Stellenanzeigen. Ein einziger LinkedIn-Sweep brachte kürzlich 112 Ergebnisse. In diesem Jahr hat die Pipeline mehr als 1.500 Anzeigen bewertet. 1.539 davon wurden aussortiert.&lt;/p&gt;

&lt;p&gt;Wie viele Bewerbungen ich wirklich abgeschickt habe? Eine Handvoll.&lt;/p&gt;

&lt;p&gt;Dieses Verhältnis ist der ganze Punkt. Ich bin Quereinsteiger und über vierzig. Fünf Jahre bei der Lloyds Banking Group, acht Jahre als Postbote, zwei Jahre als Windows-Systemadministrator. Heute arbeite ich in der Druckproduktion bei Amazon. Dieses Jahr habe ich mein Informatik-Studium abgeschlossen (BSc Computing and IT, Open University). Einen professionellen Titel als Softwareentwickler habe ich noch nicht. Ich suche den ersten. Und er muss remote sein.&lt;/p&gt;

&lt;p&gt;Stellenbörsen sind anstrengend. Für mich waren sie besonders anstrengend, denn ich filtere nach engen Kriterien und habe den Titel noch nie getragen, auf den ich mich bewerbe. Also baute ich mir die Software, die ich nicht kaufen konnte.&lt;/p&gt;

&lt;h2&gt;
  
  
  Die Pipeline
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Stufe 1, Sammeln.&lt;/strong&gt; Sechzehn API- und RSS-Quellen. Dazu Playwright-Sweeps für die Börsen ohne API: Indeed, StepStone, LinkedIn (mit gespeicherter Session) und die Arbeitsagentur mit tiefen Suchbegriffen. Alles landet in einem Speicher mit Deduplizierung. Keine Anzeige wird zweimal verarbeitet.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stufe 2, Harte Filter.&lt;/strong&gt; Bevor ein Modell etwas sieht, sortieren billige Regeln aus. "Senior" im Titel? Weg. Stadt außerhalb meines Radius? Weg. Mehr als drei Jahre Berufserfahrung gefordert? Nicht meine Ebene. Diese Filter sind bewusst keine Modellaufrufe: Sie kosten nichts und man kann sie prüfen.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stufe 3, KI-Bewertung.&lt;/strong&gt; Die Überlebenden liest ein Sprachmodell. Es bewertet die Passung gegen mein ehrliches Profil. Auch die Einschränkungen, die sonst erst im Interview auffallen. Rollen mit "verhandlungssicher Deutsch in Wort und Schrift" für Kundenkontakt sind für mich nichts — mein schriftliches Deutsch ist B1. Interner Team-Kontakt auf Deutsch ist dagegen fein, gesprochen bin ich auf C1-Niveau.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stufe 4, Verifizierung.&lt;/strong&gt; Diese Stufe hat sich ihren Platz hart verdient. Aggregator-Titel schmeicheln. Sechs perfekte LinkedIn-Kandidaten starben, als ich den echten Anzeigentext las. Die "Junior"-Stelle wollte fünf Jahre Erfahrung. Die "Remote"-Stelle wollte drei Tage vor Ort in einer anderen Stadt. Die Regel ist jetzt absolut: Nichts kommt in die Bewerbungsliste, bevor der echte Anzeigentext geladen und gelesen wurde.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkobnjll5pj84uns8vo5g.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkobnjll5pj84uns8vo5g.png" alt="Wöchentlicher Sweep gegen die daraus entstehende Confidence-Liste: 112 Anzeigen rein, 12 bewerbenswert." width="800" height="276"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stufe 5, der Mensch.&lt;/strong&gt; Ich öffne die URL selbst. Ich lese die Anzeige selbst. Dann schreibe ich genau das, was das Formular verlangt. Eine Bewerbung nach der anderen. Keine Massen-Anschreiben. Wenn Bewerbungen teuer sind, liest man wirklich. Genau das ist die Funktion.&lt;/p&gt;

&lt;h2&gt;
  
  
  Was ich gelernt habe
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Filter hart, bevor du das Modell aufrufst.&lt;/strong&gt; Regeln sind kostenlos. Tokens sind es nicht.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Lass die KI nie Stellenanzeigen erfinden.&lt;/strong&gt; Ein Modell, das man nach Stellen fragt, erfindet glaubwürdige Anzeigen mit plausiblen URLs. Meine Pipeline bewertet nur, was die Scraper wirklich geladen haben.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Die letzte Meile bleibt menschlich.&lt;/strong&gt; Die Pipeline soll mich wählerisch machen, nicht faul.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Für Quereinsteiger ist die Pipeline das Portfolio.&lt;/strong&gt; Ich wartete lange auf ein Projekt, das beweist, dass ich Software bauen kann. Irgendwann merkte ich: Der ehrlichste Beweis lief längst. Getestetes Python, echte Scraper, Deduplizierung, CI. Ein System im täglichen Einsatz, mit echten Folgen. Die Werkzeuge sind öffentlich: &lt;a href="https://github.com/Reaver1000/job-sweep" rel="noopener noreferrer"&gt;job-sweep&lt;/a&gt; ist das Sweep-Toolkit, &lt;a href="https://github.com/Reaver1000/remote-job-engine" rel="noopener noreferrer"&gt;remote-job-engine&lt;/a&gt; übernimmt Suche und Bewertung. Eines der Projekte läuft als Live-Demo: &lt;a href="https://sql-query-builder-uzsrs2gl2af8avqsxappchw.streamlit.app" rel="noopener noreferrer"&gt;SQL Query Builder&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Was kommt
&lt;/h2&gt;

&lt;p&gt;Ich suche eine Junior- oder Associate-Rolle — KI, Automatisierung oder Daten. Vollständig remote aus Deutschland oder aus Großbritannien (ich bin britischer Staatsbürger). Alles über mich steht auf &lt;a href="https://reaver1000.github.io" rel="noopener noreferrer"&gt;reaver1000.github.io&lt;/a&gt;, dort gibt es auch eine deutsche Seite.&lt;/p&gt;

&lt;p&gt;Und wenn du selbst auf Jobsuche bist: Bau das Werkzeug, bevor du dem Board vertraust. Das Board hat deine Interessen nicht im Blick. Deine Pipeline schon — du hast sie geschrieben.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>automation</category>
      <category>career</category>
      <category>deutsch</category>
    </item>
    <item>
      <title>Errors are data: what building a small ETL framework taught me</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Fri, 09 Oct 2026 13:28:26 +0000</pubDate>
      <link>https://dev.to/reaver1000/errors-are-data-what-building-a-small-etl-framework-taught-me-3mhn</link>
      <guid>https://dev.to/reaver1000/errors-are-data-what-building-a-small-etl-framework-taught-me-3mhn</guid>
      <description>&lt;p&gt;Most tutorials show you pandas in a notebook. Real data work is a scheduled job with three sources, and one of them is broken, and nobody is watching when it runs.&lt;/p&gt;

&lt;p&gt;That gap is why I built &lt;a href="https://github.com/Reaver1000/etl-data-pipeline" rel="noopener noreferrer"&gt;etl-data-pipeline&lt;/a&gt;: a small, composable extract-transform-load framework in Python with a full test suite and CI. It ingests deliberately messy sample data, stray whitespace, inconsistent casing, a missing email, duplicate rows etc cleans it, loads it into SQLite, and reads the table back to prove the roundtrip. Twenty-one tests. You can run the whole demo in under a minute:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-r&lt;/span&gt; requirements.txt
python demo.py
pytest
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It is not Airflow. It is not dbt. It is a few hundred lines that do one job,  and building it taught me four things that notebooks never will.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 1: errors are data, not exceptions
&lt;/h2&gt;

&lt;p&gt;My first version raised on the first bad row. Then I imagined the scheduled-job reality: one dead API source at 3am, an exception halfway through the run, and half the data loaded with no record of what survived. So the extractors and loaders in this framework never raise. Every stage returns a result object with an errors list, and the pipeline produces a structured run report: per-stage record counts, successes, errors, timing.&lt;/p&gt;

&lt;p&gt;A full report at the end of a broken run beats a stack trace in the middle of it. Errors became rows in the report, and the report became the thing I actually read.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 2: schema mapping is a whitelist, not a copy
&lt;/h2&gt;

&lt;p&gt;Upstream APIs grow fields without warning, and "just copy everything" is how an unreviewed column sneaks into your database. The &lt;code&gt;FieldMapper&lt;/code&gt; stage only copies fields you explicitly mapped and deliberately drops everything else. Mapping became a security decision, not just a renaming convenience.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 3: SQL identifiers cannot be parameterised
&lt;/h2&gt;

&lt;p&gt;Values in SQLite can be bound as parameters. Table and column names cannot . They have to be interpolated into the DDL string. So the loader validates the table name and quotes identifiers, while all values stay parameterised. There is an injection test in the suite that documents exactly this edge, because it is the one place a "just use parameterised queries" rule quietly fails.&lt;/p&gt;

&lt;p&gt;If you learn one paranoid habit from this post: decide, per identifier, whether it comes from your code (fine) or from anywhere else (validate it first).&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 4: tests never touch the network
&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;APIExtractor&lt;/code&gt; tests mock &lt;code&gt;requests.get&lt;/code&gt;. Everything else runs against pytest's &lt;code&gt;tmp_path&lt;/code&gt;. That decision, more than any cleverness, is why the suite runs in seconds and never flakes. It also forced the code into honest seams, if you cannot mock the boundary, the boundary is in the wrong place.&lt;/p&gt;

&lt;h2&gt;
  
  
  The composable part
&lt;/h2&gt;

&lt;p&gt;Every stage is one abstract method. Subclass &lt;code&gt;Extractor&lt;/code&gt;, &lt;code&gt;Transformer&lt;/code&gt;, or &lt;code&gt;Loader&lt;/code&gt;, implement the one method, and the pipeline treats it like any other stage. I added an extractor for a new JSON response shape by writing a few lines, not a new framework.&lt;/p&gt;

&lt;p&gt;That is the quiet punchline for other career-changers like me (I wrote this while finishing a Computing and IT degree after 13 years in operations): the big orchestration tools are composable stages with run reports and whitelists underneath. Building the small version once teaches you what the big version is actually doing. Now when a job description says "experience with ETL tooling", I can say what I did, show the code, and point at the tests.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;The repo is public: &lt;a href="https://github.com/Reaver1000/etl-data-pipeline" rel="noopener noreferrer"&gt;github.com/Reaver1000/etl-data-pipeline&lt;/a&gt;. Fork it, break it, extend it. The design notes in the README cover the extension points, and the CI badge is green.&lt;/p&gt;

&lt;p&gt;I am a junior developer looking for my first software engineering title. If your team does data work in Python and this style of thinking fits, everything about me is at &lt;a href="https://reaver1000.github.io" rel="noopener noreferrer"&gt;reaver1000.github.io&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>python</category>
      <category>data</category>
      <category>testing</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>I built an AI that finds and scores my next job</title>
      <dc:creator>David Buchan</dc:creator>
      <pubDate>Thu, 08 Oct 2026 21:12:02 +0000</pubDate>
      <link>https://dev.to/reaver1000/i-built-an-ai-that-finds-and-scores-my-next-job-49je</link>
      <guid>https://dev.to/reaver1000/i-built-an-ai-that-finds-and-scores-my-next-job-49je</guid>
      <description>&lt;p&gt;Every week my tooling sweeps around twenty job sources and pulls in a few hundred postings. A single recent LinkedIn sweep returned 112 results. Over this year the pipeline has evaluated more than 1,500 postings and parked 1,539 of them.&lt;/p&gt;

&lt;p&gt;The number of jobs I have actually applied to? A handful.&lt;/p&gt;

&lt;p&gt;That ratio is the whole point. I am a career changer in my forties. Five years in banking operations at Lloyds, eight years delivering mail, two years as a Windows sysadmin, and currently I run print production shifts at an Amazon facility. This year I finished a BSc in Computing and IT with the Open University. What I do not have is a professional software engineering title, so I am hunting for my first one, and I need it remote.&lt;/p&gt;

&lt;p&gt;Job boards are exhausting for everyone, but they are especially exhausting when you are filtering for a narrow set of constraints and you have never held the title you are applying for. So I built the tooling I could not buy.&lt;/p&gt;

&lt;h2&gt;
  
  
  The pipeline
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Stage 1, collection.&lt;/strong&gt; Sixteen API and RSS sources, plus Playwright-based sweeps for the boards that have no API: Indeed, StepStone, LinkedIn (via a saved session), and the German Arbeitsagentur job board with deep search terms. Each source writes a markdown file of raw results, and everything lands in a SQLite-backed dedupe store so no posting is ever processed twice.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stage 2, hard elimination.&lt;/strong&gt; Before any model sees anything, cheap deterministic filters kill the obviously wrong postings. A title containing "Senior" when the range is junior. A city outside my radius. Recruiter spam patterns. Skills bars over three years of professional experience, because "Erste Erfahrung" (first experience) is fine for me and "5+ years" is not. These filters are strings and rules, not model calls, and that is deliberate: they cost nothing and they are auditable. At last count the confidence list held 12 survivors, 23 maybes, and 1,539 parked. The parked bucket being enormous is the system working correctly.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkobnjll5pj84uns8vo5g.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkobnjll5pj84uns8vo5g.png" alt="Actual output from the weekly sweep versus the confidence list it feeds: 112 postings in, 12 apply-worthy survivors." width="800" height="276"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The funnel in one picture: a weekly LinkedIn sweep produces 112 raw results; after dedupe, hard elimination, and body-verification, the apply-now queue holds 12.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stage 3, LLM scoring.&lt;/strong&gt; The survivors get read by a language model that scores fit against my honest profile, including the constraints that usually get discovered at the interview stage. Written German at B1 means customer-facing roles demanding "verhandlungssicher Deutsch in Wort und Schrift" are a no for me, while internal team communication in German is fine because my spoken German is C1. Encoding these rules as a prompt instead of gut feeling removed a whole class of optimistic mistakes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stage 4, verification.&lt;/strong&gt; This is the stage that earned its place the hard way. Aggregator titles flatter. Six consecutive LinkedIn candidates that looked perfect by title died when I fetched the actual posting body: the "junior" role wanted five years, the "remote" role wanted three days on-site in another city, the "AI engineer" role was actually a data-labeling gig. The rule now is absolute: nothing enters the apply queue until the real posting body has been fetched and read.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stage 5, the human.&lt;/strong&gt; I open the URL myself and read the posting myself. Then I draft exactly what the form requires, one application at a time. No batch-generated cover letters, no auto-submit. When applying is expensive you actually read, and that is the feature.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I learned building it
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Filter hard before you call the model.&lt;/strong&gt; Rules are free, tokens are not, and determinism beats cleverness for anything you would want to debug at 6 a.m. before a shift.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Never let an LLM generate the job postings.&lt;/strong&gt; Left alone, a model asked to "find jobs" will happily invent believable postings with plausible URLs. Mine only ever ranks what the scrapers actually fetched. Every URL in the queue was downloaded from a real board.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The last mile should stay human.&lt;/strong&gt; The pipeline's job is to make me picky, not lazy. Automation found me a short list worth reading carefully, and the careful reading is mine.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;For a career changer, the pipeline is the portfolio.&lt;/strong&gt; I kept waiting for a project impressive enough to prove I could engineer software. At some point I noticed the most honest proof was already running: tested Python, real scrapers, a dedupe store, CI on the ETL framework, and a system in daily use solving a real problem with real stakes. The tools in this post are public: &lt;a href="https://github.com/Reaver1000/job-sweep" rel="noopener noreferrer"&gt;job-sweep&lt;/a&gt; is the scrubbed sweep toolkit, and &lt;a href="https://github.com/Reaver1000/remote-job-engine" rel="noopener noreferrer"&gt;remote-job-engine&lt;/a&gt; handles discovery and scoring.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is next
&lt;/h2&gt;

&lt;p&gt;I am available for junior or associate roles from November 2026, fully remote from Germany or UK-remote as a British citizen. If you are hiring for AI integration, automation, data, or QA work and any of this resonates, everything is on my site: &lt;a href="https://reaver1000.github.io" rel="noopener noreferrer"&gt;reaver1000.github.io&lt;/a&gt;, or find me on &lt;a href="https://www.linkedin.com/in/david-a-buchan/" rel="noopener noreferrer"&gt;LinkedIn&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;And if you are also job hunting in this market: build the tool before you trust the board. The board does not have your interests at heart. The pipeline does, because you wrote it.&lt;/p&gt;

</description>
      <category>python</category>
      <category>ai</category>
      <category>career</category>
      <category>automation</category>
    </item>
  </channel>
</rss>
