DEV Community: Shashank Raj

I Turned My Google Sheets Hack Into a Real Tool. It Took Six Months and I Have No Regrets.

Shashank Raj — Sun, 05 Apr 2026 15:55:13 +0000

Six months ago I wrote about automating my standups with a Google Sheet, a cron job, and the kind of infrastructure that makes real engineers wince. Nightly runs. A Docker container on EC2. Apps Script that worked until it didn't. The whole thing was duct tape at scale, and I was weirdly proud of it.

Then my PM asked me to update the ticket before the standup, not after.

The sheet broke. The cron job silently failed for three days. And I found myself, at 11pm on a Wednesday, manually updating four Jira tickets while my Apps Script sat in production doing absolutely nothing, successfully.

That was the night I decided to rewrite the whole thing properly.

The New Problem (Same as the Old Problem, Just More Honest)

The Google Sheet approach had one fatal flaw: it was still me doing work. I was just doing it in a spreadsheet instead of a Jira UI. Every night. Before midnight. In a specific format. Because if the format was wrong, the script silently ate the row and nobody found out until the standup.

What I actually wanted was: commit code, ticket updates itself, standup writes itself, I do nothing.

Not a dashboard. Not a different place to type. Nothing.

The tooling for this apparently doesn't exist if you want it to work locally, with your own LLM, without sending every commit message to a SaaS vendor who charges per-seat.

So, naturally, I built it.

What I Actually Built

DevTrack is a Go daemon that watches your git repositories. When you commit, it fires. When a timer hits (configurable — mine is every 90 minutes), it fires. Each trigger gets routed over HTTP to a Python backend that runs NLP, calls an LLM, figures out what you were working on, and pushes an update to whatever PM tool you use.

The binary is 5MB. The AI runs locally on Ollama if you want. The whole thing runs offline.

Here's what the commit flow actually looks like now:

$ git add backend/auth/session.py
$ devtrack git commit -m "fix session expiry on token refresh"

What happens next, without me touching anything:

The commit message goes through an AI pass — not to rewrite it, just to enrich it with context (branch name, open PR, recent related commits)
The NLP layer extracts that this touched auth, cross-references my open Azure work items
A comment gets posted on the relevant ticket: "Session expiry fix applied — token refresh flow updated in commit a3f91c"
The ticket moves from "In Progress" to "Review" because the branch name followed the pattern
That evening's standup already has a bullet point waiting for me

The whole thing from devtrack git commit to ticket comment: about 4 seconds.

The Numbers After Six Months

I've been running this on my own projects since October. Here's what the logs actually say:

~23 minutes saved per day on ticket updates, standup prep, and EOD reports
94% of work items updated automatically — the 6% that missed were commits on branches I'd explicitly told it to ignore
Standup is pre-written 4 out of 5 days — I edit it, I don't write it
Zero nights of 11pm manual Jira sessions since January

That last one is the one that still surprises me. Not because the automation is perfect — it isn't — but because the bar for "good enough to post" is so much lower than I thought. A ticket comment that says "touched auth layer, see commit a3f91c" is genuinely more useful than the nothing that was there before.

The Part I'm Still Not Proud Of

Setting up Ollama for the first time is a pain. If you've never done it, you'll spend 45 minutes figuring out which model to pull, why the first model you tried is too slow, and what nomic-embed-text is and why you apparently need it.

The documentation exists but it's scattered, and I'm only now admitting that this is my fault not Ollama's.

Also, the .env setup has 12 required variables. I know. I needed them all for different things and at some point the config grew teeth. There's a sample file, but I know what it looks like to someone encountering it for the first time. I'm working on a devtrack setup wizard that holds your hand through the first run.

The Part That Still Feels Like Magic

The personalization feature. I spent a month building a pipeline that reads your Teams messages, extracts how you communicate, and makes the AI generate updates in your voice. The standup bullets sound like me — short sentences, no filler words, specific rather than vague.

My manager asked me last month if I'd started writing better status updates.

I said yes.

What's Actually Shipping Today

DevTrack v1.0 went out this morning. Multi-platform binaries on GitHub Releases — macOS arm64/amd64, Linux arm64/amd64. Fully local, no account, no API key required if you use Ollama.

The features I actually use every day:

Git commit interception with AI enhancement
Azure DevOps, GitHub, and Jira PM sync
Ticket alerter (no more tab-switching to check if something was assigned to me)
EOD report generator that pulls from the day's commit history
git-sage — an agentic git tool for the messy stuff (rebases, conflict resolution, squash flows)

The features I built but use less often: GitLab integration, the Telegram bot for remote prompts, the Teams learning pipeline. They work, they're just not part of my daily loop.

The Honest Pitch

If you spend more than 15 minutes a day updating tickets or writing standup notes by hand, DevTrack will probably save you time. If your team uses Azure DevOps or GitHub, it'll save you more.

If you want it to run entirely on your machine, on a local model, with no data leaving your laptop — it does that. That was actually the point.

If you want a 60-second demo: git commit, watch a ticket comment appear. That's the whole thing.

The code is at github.com/sraj0501/automation_tools. The Google Sheet is retired. The cron job is gone. Apps Script never knew what hit it.

Next post: I'm building a local-first admin console for the server mode, and a two-month experiment starts Monday where an AI agent does all my commits while I watch and write about what happens. Should be either enlightening or a disaster. Probably both.

Finding Balance in AI-Powered Creation

Shashank Raj — Fri, 06 Feb 2026 20:07:20 +0000

We live in an era where incredible resources are at our fingertips. The idea of having an AI as a teacher, mentor, or even a rigorous critic feels almost unbelievable. I’ve been experiencing this firsthand with a project deeply personal to me – a solution designed to solve a particular challenge I’d been wrestling with. I poured nearly a year into it, meticulously architecting every layer, confident that I'd created something truly bespoke.

Initially, I welcomed the assistance of AI. It felt like a superpower, accelerating the process and refining details. The results looked impressive, almost flawlessly operational.

But as the project’s scope broadened, a subtle unease began to creep in. It started with minor tweaks, then suggestions for entirely new features. Slowly, insidiously, the project began to evolve beyond my initial vision. The unique fingerprint of my original intent, the core 'why' that fueled its creation, began to blur.

There was a point where I felt a disconcerting sense of distance. It wasn’t a complete disconnect, but more akin to observing something I’d helped create, but no longer fully controlled. The intricate framework I'd built started to feel like a complex machine – impressive, certainly, but increasingly opaque. It evoked a feeling of being on the periphery, a spectator to a development I had initiated.
I found myself hesitating to use it, reluctant to share it, feeling a pang of almost parental protectiveness towards something that had, in a way, surpassed its origin.

There’s a deeply ingrained societal expectation – a pressure, perhaps – to demonstrate resilience, to avoid acknowledging any form of setback. The thought crossed my mind: "Real men don't accept defeat." But then I realized that wasn't a badge of honor; it was a limitation. A refusal to admit that I might have taken a wrong turn, or allowed a tool to guide me too far afield.

The turning point wasn’t a dramatic epiphany, but a gradual shift in perspective. I realized I’d been allowing AI to dictate how the project evolved, rather than guiding where it should go. The mistake wasn't in using AI; it was in relinquishing the driver’s seat. I needed to repurpose it – not as an autopilot, but as a sophisticated navigation system. A source of insights, a generator of possibilities, but ultimately under my direction.

It’s humbling to reflect on how far we’ve come. I vividly remember the late nights spent fighting for access to a command line interpreter, just to run a simple Python script. Now, the challenges are of a different order, and AI offers an incredible array of capabilities. But the fundamental principle remains: true innovation comes from combining technology with human intention, and maintaining a sense of ownership over the creative process. It’s a lesson I’ll carry forward, ensuring that the next iteration reflects not just technical prowess, but the heart and soul of the original vision.

Beyond the Illusion: Are AI Models Learning to Reason by Knowing Their Limits?

Shashank Raj — Fri, 13 Jun 2025 14:29:10 +0000

Introduction: The Debate About AI Reasoning

Apple's recent paper "The Illusion of Thinking" argues that AI models can't truly reason—they're just sophisticated pattern-matching machines without real understanding. But there's an interesting counter-trend emerging.

Newer AI models like Claude and Copilot are behaving differently than older ones. When faced with complex tasks, they increasingly suggest using external tools or ask for clarification instead of just giving potentially wrong answers. This shift suggests something important about how AI is evolving.

Learning from Human Behavior
Consider this scenario: You need to sort 1,000 books in one hour. Initially, you might try to go faster, working carelessly. But a smart person would eventually recognize the impossible deadline and either:

Show only what they completed and admit they ran out of time
Suggest a better approach or ask for more time

This mirrors what we're seeing in AI. Older models might "hallucinate" or give incomplete answers when hitting their limits. Newer models are more like the smart human—they recognize their constraints and suggest better ways to solve the problem.

What AI Models Can't Do Well
Current AI models have several key limitations:

Limited Understanding: They process patterns in text but don't truly "understand" meaning like humans do. They often miss context, sarcasm, or common sense.

Outdated Knowledge: They only know what was in their training data and can't access current information or learn new facts during conversations.

Memory Problems: Each conversation starts fresh—they don't remember previous chats unless reminded.

Context Limits: They can only process a limited amount of text at once, like having a small working memory.

Hallucinations: When they don't know something, they often confidently make up plausible-sounding but false information.

Bias Issues: They can reflect and amplify biases present in their training data.

The Solution: AI + Tools = Better Performance
The breakthrough isn't making AI models smarter internally—it's connecting them to external tools. This approach addresses their core limitations:

Knowledge Tools: Web search and document retrieval give AI access to current and specialized information.

Memory Tools: External storage systems help AI remember previous conversations and build on past work.

Calculation Tools: Specialized programs handle complex math, data analysis, and logical operations.

Action Tools: APIs let AI interact with other software, databases, and services.

When an AI suggests "use a search engine for current information" or "let's break this into smaller steps," it's demonstrating strategic thinking about problem-solving, even if it's engineered rather than conscious.

Building Specialized AI Solutions
To create effective AI tools for specific tasks (like analyzing log files), follow this approach:

Define Clear Boundaries: Specify exactly what the AI should and shouldn't do
Choose the Right Base Model: Pick an AI model suited for your domain
Add Specialized Tools: Connect databases, APIs, and processing tools relevant to your task
Create Smart Coordination: Build a system that knows when to use which tool
Include Feedback Loops: Monitor performance and continuously improve

This modular approach works better than trying to build one perfect AI that does everything.

What This Means for the Future
This evolution doesn't necessarily mean we're close to Artificial General Intelligence (AGI)—AI that matches human intelligence across all domains. However, it represents something valuable: practical intelligence.

AI systems are becoming better at:

Recognizing their own limitations
Communicating these limitations clearly
Suggesting effective alternatives
Coordinating multiple tools to solve complex problems

This "know what you don't know" approach makes AI more trustworthy and useful in real-world applications.

Conclusion

We're entering an era of pragmatic AI—systems that may not think like humans internally, but can solve problems effectively by knowing their limits and using the right tools. This represents a shift from trying to build one super-intelligent AI to creating intelligent ecosystems of specialized components working together.

The future of AI may be less about creating artificial consciousness and more about building smart, tool-using systems that can tackle complex real-world challenges through strategic coordination and clear communication about their capabilities.

The Daily Standup Slayer: How This Lazy Manager Automated Everything (Except Meetings)

Shashank Raj — Fri, 27 Sep 2024 16:46:42 +0000

Let's face it, meetings are the beige walls of the productivity world. You know, endless loops of "what could have been" and "should have been" while everyone wrestles over a shrinking timeframe. Articles debunking their usefulness pile up like unread emails, but the charm of a good standup seems unshakeable for some (cough management cough).

So, here I was, a DevOps and system reliability magician, leading a team of Gen-Z developers who wouldn't fill a single tracker, let alone the holy trinity of email updates, fancy project management tools, and good ol' Excel.

We were deadlocked.

Management craved updates everywhere, the devs rebelled against everything, and my job search was going nowhere fast.
Enter automation, the hero in this data-driven odyssey. What if the devs filled one glorious sheet and we used that sheet to conquer all? Talk about killing multiple birds with a few well-aimed scripts!

Step 1: Building a Fortress of Simplicity

First, a template. Think Bunk Beds: easy to understand, enough room for (almost) everything, and compatible with most project management tools on the market. Google Sheets became my weapon of choice, thanks to their fantastic Python API documentation.

(https://developers.google.com/sheets/api/quickstart/python)

Step 2: Operation "Fill the Darn Sheet" (Good Luck!)
Next, convincing the devs to actually fill this daily. Let's just say my negotiation skills were put to the test. Think Jedi mind tricks, minus the lightsabers.

Step 3: Let the Automation Take Flight
Now, the fun part! Imagine a "set it and forget it" solution, a tireless workhorse that runs once and keeps chugging along. Here's the Pythonic breakdown:

Grab the Credentials: We need to authenticate with Google's servers, but hey, only once (thanks, refresh tokens!). This generates a magical "token.json" file, which holds the key to our automated kingdom.

Data Download: Using the Python API, we dive into Google Sheets and extract the glorious data. Pandas, our data wrangling champion, helps us filter for the latest updates.

Transformation Time: We shape that data into a format that Jira, Youtrack, or your PM tool of choice understands.
Dissemination is Key: The transformed data gets transformed into a json/ csv structure of your chosen project management tool and a friendly email with the latest updates gets sent out to a designated distribution list (think "no-reply" for your sanity).

This json / csv file can be copied directly to Youtrack / Jira, one field at a time, because CTRL+C and CTRL+V is the greatest human invention of all time for us mere programmers.

A Few Caveats for the Cautious:

Remember, the free tier of the Google Sheets API has limitations. Think data on a diet – small and lightweight for optimal processing.

To avoid polling the entire sheet every time, I employed a Google Apps Script to sort the data by date. Knowing my developers wouldn't write essays in the update section (bless their Gen-Z brevity), I limited the data grab to a mere 20 rows.

We're talking about targeted data extraction, people, not an epic download marathon!

Deployment Shenanigans

With the Python API, I snatched 10 rows of data from the Google Sheet (defined in an environment variable, because who wants hardcoded stuff?). Then, a Google account with the same project was set up to access Gmail (the email hero!).

https://developers.google.com/gmail/api/guides/sending#python

Finally, I whipped up some Docker magic to streamline deployment. The code, nestled snugly in a Docker container, landed on an AWS development instance, where a cron job awaited its cue.

The Grand Automation Symphony

Here's the grand finale:

End of Day: Developers and I (reluctantly) fill out the glorious template.
11 PM: The Google Sheets Apps Script springs into action, sorting the entire sheet by date (may require a silent prayer to the tech gods).
12:30 AM: A cron job fires on the EC2 instance, launching a Docker container with the Python code.
The Code Does Its Thing: Reads the Google Sheet, transforms the data, injects it into the PM tool, sends the update email, and then… sleeps soundly.
Wake up to the sweet symphony of the updates, or the lack thereof:

The Inevitable Hiccups (and Dreams of Grandeur)

Let's be honest, the Apps Script can be a bit flaky sometimes, forcing me to resort to manual sorting (a developer's burden, I know).

Plus, I built a template for Jira integration, but full automation remains a future quest.

Maybe one day, I'll conquer API integrations with major PM tools, build a product, secure VC funding, and sell it to Atlassian.

But hey, this is the Lazy Manager's Guide, for now.