DEV Community: Dakshata

LazyLora — Open-Weight Intent, Durable Escalation, Zero Babysitting

Dakshata — Thu, 22 Oct 2026 19:38:36 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

On a busy ward a coordinator used to send the same shift text to six people, wait, chase the ones who didn’t reply, then escalate by phone. The replies were never clean. “yeah sure”, “nah booked”, “what time again?”. Keyword rules broke. Someone had to stay online.I built the thing that stays online instead.
LazyLore is a small FastAPI service that fans out shift offers, understands messy caregiver replies with a local open-weight model, claims the first valid accept under a lock, and escalates to voice if nobody answers. The humans only start it. The rest runs while they do something else.

Who gets to be lazier?

Coordinators stop manually texting and chasing people
Caregivers can reply casually instead of using rigid keywords
The system keeps running even if the model or Temporal is temporarily down (graceful fallback)

Piece	What it does
Fan-out	Sends SMS notifications to every caregiver with the matching role.
Intent	Uses local Gemma (`gemma2:2b` via Ollama) to classify responses as `ACCEPT`, `DECLINE`, or `UNKNOWN`.
Claim	The first valid acceptance wins; an `asyncio` lock prevents multiple caregivers from claiming the same request.
Escalation	A Temporal workflow waits for a specified interval, then places phone calls if the request is still pending.
Fallback	If Ollama or Temporal is unavailable, the service degrades gracefully instead of crashing.

Demo

Running it locally

The project in VS Code. The terminal list on the right shows the Temporal server (temporal), the API (uv), and two PowerShell tabs for sending requests and running tests.

The setup is three pieces running side by side:

Temporal server: temporal server start-dev starts a local server and a web UI at localhost:8233.
The API: uv run uvicorn app.api:create_app --factory --reload --port 8000. The Temporal worker starts inside it, so there is no separate worker to run.
Ollama: it runs in the background after installation, and the app uses it to classify replies. You don't need a terminal for it.

The other two PowerShell tabs are for sending test requests with Invoke-RestMethod and running the tests.

At the bottom of the screenshot is the test run (uv run pytest -v): all 5 tests pass in under 3 seconds. They cover the intent parser, including accept, decline, unknown, fallback on error, and messy replies like "yeah sure I can take it".
Local run is three terminals: Ollama, Temporal worker, FastAPI. One curl starts the fan-out. Natural-language replies claim the shift. After the demo delay the worker escalates if nobody claimed it.

Code

the-matrixneo / LazyLora

LazyLore (with Local Open-Weight AI)

A Python FastAPI microservice that fills open caregiver shifts by fanning out SMS (and escalating to voice), accepting the first valid claim, and handling race conditions safely.

Hacktoberfest 2026 – Week 3 “Slow and Steady”
The service now uses a local open-weight model (via Ollama) to understand messy real-world replies instead of brittle keyword matching. This means:

messages never leave your machine
Zero ongoing LLM API cost
Works fully offline once the model is pulled
Handles natural language (“yeah sure”, “nah I’m booked”, “what time again?”) so coordinators can be lazy

Quick Start (with open-weight model)

1. Install & start Ollama

curl -fsSL https://ollama.com/install.sh | sh
ollama serve          # leave this running
ollama pull gemma2:2b # or phi3:mini / llama3.2:1b

2. Install project dependencies

uv sync

3. Run the API

uv run uvicorn app.api:create_app --factory --reload

4. Test the intent classifier

uv run pytest tests/test_intent.py…

View on GitHub

Core files:

app/intent.py — zero shot Gemma classifier, temperature 0, falls back to UNKNOWN
app/workflows.py + worker.py — Temporal escalation with retries
app/api.py — fan-out, claim lock, Temporal start with asyncio fallback.

How I built it

The idea

When a shift opens, LazyLora texts every caregiver with the right role. The first person to reply "yes" gets the shift. If nobody claims it in time, it escalates to phone calls. I wanted this to be reliable, so I used Temporal for the waiting and escalation instead of a plain timer.

Architecture

Everything the app owns runs in one Python process (FastAPI + uvicorn). Around it are two local services: a Temporal dev server and Ollama. As the image below shows that a Fan-out → natural-language accept → first claim wins → second request rejected
All intent classification runs locally with Gemma via Ollama.

All intent classification runs locally with Gemma via Ollama." width="800" height="516">

Piece	Job
FastAPI routes	`POST /shifts/{id}/fanout` opens a shift, `POST /messages/inbound` receives replies, `GET /health` checks the service
In-memory store	Holds shifts, caregivers, and fanouts, loaded from `sample_data.json` on startup
Claim lock	One `asyncio.Lock` per shift, so only one caregiver can claim it
Intent parser	Sends each reply to a local model (gemma2:2b via Ollama) and returns ACCEPT, DECLINE, or UNKNOWN. If the model is down, it falls back to UNKNOWN instead of crashing
Notifier	`send_sms` and `place_phone_call`. These are mocked for the demo, so no real messages are sent
Temporal server	Stores the workflow and its timer outside the app, so the timer survives restarts
Temporal worker	Runs the escalation workflow and activity. It starts inside the API process

Project layout

LazyLora/
├── app/
│   ├── api.py        # routes, claim lock, worker startup
│   ├── database.py   # in-memory store + sample data loader
│   ├── intent.py     # reply classification (Ollama)
│   ├── models.py     # InboundMessage, ShiftFanout, statuses
│   ├── notifier.py   # mocked SMS and phone calls
│   └── workflow.py   # Temporal workflow + activity
├── tests/
│   └── test_intent.py
├── worker.py         
└── sample_data.json

Step 1: Open a shift and text the caregivers

The fanout endpoint is idempotent, so posting the same shift twice never texts anyone twice. It saves the shift as PENDING and starts a Temporal workflow named escalate-{shift_id}.

@router.post("/shifts/{shift_id}/fanout")
async def fanout_shift(shift_id: str):
    db = get_db()
    shift = db.shifts.get(shift_id)
    if shift is None:
        raise HTTPException(status_code=404, detail=f"Shift {shift_id} not found")

    if db.fanouts.get(shift_id) is not None:
        return {"status": "already_fanout"}

    caregivers = db.get_caregivers_by_role(shift.role_required)
    for c in caregivers:
        await send_sms(c.phone, "New shift available. Reply 'yes' to claim.")

    db.fanouts.put(shift_id, ShiftFanout(
        shift_id=shift_id,
        status=ShiftFanoutStatus.PENDING,
        contacted_caregiver_ids=[c.id for c in caregivers],
    ))

    client = await Client.connect("localhost:7233")
    await client.start_workflow(
        ShiftEscalationWorkflow.run,
        shift_id,
        id=f"escalate-{shift_id}",
        task_queue="shift-escalation",
    )
    return {"status": "fanout_initiated"}

Step 2: Let the first "yes" win

Replies don't have to match a keyword. "yes I can take it" and "yes put me down" both get classified as ACCEPT. Then a lock makes sure only one person claims the shift, even if replies arrive at nearly the same time:

lock = await _get_claim_lock(fanout.shift_id)
async with lock:
    # Re-check inside the lock: someone may have claimed while we waited
    fanout = db.fanouts.get(fanout.shift_id)
    if fanout is None or fanout.status != ShiftFanoutStatus.PENDING:
        return {"status": "shift_already_claimed"}

    fanout.status = ShiftFanoutStatus.CLAIMED
    fanout.claimed_by = caregiver.id
    db.fanouts.put(fanout.shift_id, fanout)

Step 3: Escalate with a durable timer

The workflow sleeps, then runs an activity. If the shift is still PENDING, it places phone calls. If someone claimed it, it does nothing.

@workflow.defn
class ShiftEscalationWorkflow:
    @workflow.run
    async def run(self, shift_id: str) -> str:
        await workflow.sleep(timedelta(seconds=30))  # 10 minutes in real use
        return await workflow.execute_activity(
            escalate_shift_activity,
            shift_id,
            start_to_close_timeout=timedelta(seconds=60),
            retry_policy=RetryPolicy(maximum_attempts=3),
        )

Step 4: Run the worker inside the API

My first version ran the worker as a separate process. Because the data lives in memory, that worker had its own empty copy and never found the shift, so the escalation silently did nothing. Starting the worker in FastAPI's lifespan fixed it, since both now share the same data:

@asynccontextmanager
async def lifespan(app: FastAPI):
    load_sample_data()
    client = await Client.connect("localhost:7233")
    worker = Worker(
        client,
        task_queue="shift-escalation",
        workflows=[ShiftEscalationWorkflow],
        activities=[escalate_shift_activity],
    )
    worker_task = asyncio.create_task(worker.run())
    yield
    worker_task.cancel()


def create_app() -> FastAPI:
    app = FastAPI(lifespan=lifespan)
    app.include_router(router)
    return app

Run it yourself

temporal server start-dev
uv run uvicorn app.api:create_app --factory --reload --port 8000
uv run pytest -v

How the flow works

The diagram has one starting point and two paths that run at the same time. Here's how to read it, top to bottom.

1. A shift opens (the blue box at the top)

A request hits POST /shifts/{id}/fanout. The app first checks that the shift exists and hasn't already been sent out, so sending the same request twice never texts people twice. Then it finds every caregiver with the required role (for example, an LPN) and sends each of them an SMS.

2. The shift is marked PENDING and a timer starts

The app saves the shift as PENDING and starts a Temporal workflow with a timer. From here the diagram splits into two paths that run at once.

3. The claim path (green box, left)

When a caregiver replies, the app:

Checks that the phone number belongs to a known caregiver.
Sends the text to a small local language model (Ollama, gemma2:2b), which labels it as accept, decline, or unknown. That means "yes I can take it" and "yes put me down" both work, with no exact keyword needed.
If it's an accept, takes a per-shift lock and checks the shift is still open.
The first caregiver through the lock gets the shift (CLAIMED). Anyone else gets shift_already_claimed.

The lock matters because two people can reply at nearly the same moment. Without it, both could be booked for the same shift.

4. The escalation path (purple box, right)

At the same time, Temporal is counting down a durable timer (30 seconds in my demo, 10 minutes for real use). When it ends, an activity checks the shift:

Still PENDING? It places a phone call to each matching caregiver and marks the shift ESCALATED.
Already claimed? It does nothing and returns already_claimed_or_missing.

Why Temporal for the timer?

A plain sleep inside the app disappears if the server crashes or restarts. Temporal stores the timer outside the app, so the escalation still fires after a restart. That's the main reason I used it here.

What I fixed

My first version ran the Temporal worker as a separate process. The app kept its data in memory, so that worker had its own empty copy and never found the shift. Escalation silently did nothing.

Here is what that looked like in the Temporal UI. The workflow list shows the escalation workflow as Completed, which looks healthy at first glance:

The workflow ran and finished, so Temporal reported success. Nothing here hints at a problem.

Opening the workflow shows the real result. The activity returned already_claimed_or_missing even though nobody had claimed the shift. The worker could not see the shift at all, so it skipped the phone calls. The timeline also shows the original 10-minute timer, which is why I later shortened it to 30 seconds for demos:

Result: already_claimed_or_missing. The workflow completed, but the escalation never happened.

The lesson: a Completed workflow only means the code ran without crashing, not that it did the right thing. Always check the result.

The fix was to start the worker inside the API's startup so both share the same data. After that, the same flow returned escalated_to_1_caregivers.

Why Does Open Innovation Matter?

Closed intent APIs would have required keys, bills, and shipping private caregiver messages off box. A local open-weight model keeps the data on the machine, costs nothing after the first pull, and still works offline. Temporal does the same for time. A plain sleep is fine until the process restarts. A workflow survives the restart. The combination of local model for understanding, durable workflow for waiting is what lets the system actually replace the human loop instead of just assisting it.

The Lazy Payoff

Before: manual texts, keyword failures, phone chases, someone watching the channel.

After: one POST starts the fan-out. Replies are understood. The first accept claims the shift under a lock. If silence continues, Temporal escalates. The coordinator’s job shrinks to “start it and, if they want, look later.”
That is the whole point of the theme. Build the thing that keeps working so the people can stop.

Prize Categories

Best Use of Gemma: Local gemma2:2b via Ollama classifies messy caregiver SMS into ACCEPT / DECLINE / UNKNOWN with temperature 0 and graceful UNKNOWN fallback.
Best Use of Temporal: Shift escalation is a Temporal workflow (sleep → activity with retries). Survives worker restarts; falls back to asyncio if Temporal is unavailable.

Red Flags in the Ledger - hf26 Challenge

Dakshata — Tue, 13 Oct 2026 08:25:29 +0000

TinyGuard AI — Simple AI Powered Expense Anomaly Detector

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

TinyGuard AI is a lightweight, AI-powered anomaly detection tool that helps users spot unusual expenses and suspicious-looking transactions in their CSV data.

Small businesses, freelancers, and independent professionals often manage their expenses using spreadsheets. Manually reviewing every transaction can be tedious, and unusual amounts can easily go unnoticed.

TinyGuard AI makes this process simpler. Upload a CSV file, select numerical features, and let the application analyze the data.

It currently includes two separate AI-powered analysis sections:

Isolation Forest: Detects unusual patterns in numerical transaction data without requiring labelled training examples.
TabPFN: Demonstrates tabular classification by predicting Normal/Review categories using a separate synthetic, labelled training dataset.

The application also provides visualizations, a results table, and downloadable analysis results.

The idea is simple: make useful AI-based data analysis accessible without requiring users to build their own machine learning pipeline.

Who would pay for it?

Freelancers, small businesses, independent consultants, and bookkeeping teams could benefit from a simple tool that helps them review expense data faster. A future version could offer recurring CSV analysis, automated reports, and integrations with accounting workflows.

Demo

Code

the-matrixneo / spill_the_tea

TinyGuard AI

A beginner-friendly web app that detects unusual records in CSV files using machine learning.

Built with Streamlit, Pandas, and Scikit-learn's Isolation Forest.

Quick Start

1. Create & activate a virtual environment

# Windows
py -m venv .venv
.venv\Scripts\activate

# macOS / Linux
python3 -m venv .venv
source .venv/bin/activate

2. Install dependencies

pip install -r requirements.txt

3. Run the app

streamlit run app.py

The app opens at http://localhost:8501 in your browser.

How to Use

Upload any CSV file (or use the included sample_expenses.csv).
Select the numeric columns you want to analyze.
Adjust the anomaly ratio slider if needed.
Click Analyze Data.
Review the results and download the annotated CSV.

Project Structure

spill_the_tea/
├── app.py                 # Main application
├── requirements.txt       # Python dependencies
├── sample_expenses.csv    # Sample data for testing
└── README.md              # This file

Requirements

Python 3.10+
See requirements.txt for…

View on GitHub

How I Built It

I built TinyGuard AI using Python and Streamlit, with a focus on keeping the application lightweight, accessible, and easy to run locally.

Tech stack:

Python — core application logic.
Streamlit — interactive web interface.
Pandas — CSV processing and data manipulation.
Scikit-learn — Isolation Forest anomaly detection.
TabPFN by Prior Labs — tabular machine learning classification.
Matplotlib — data visualization.

The application has two independent analysis pipelines. Isolation Forest identifies unusual observations, while TabPFN demonstrates classification using labelled synthetic training data. Keeping these pipelines separate makes their different purposes clear.

I also designed the interface with a soft pink and ivory aesthetic, including CSV upload, feature selection, result visualization, and downloadable outputs.

TabPFN's model weights are accessed through the required Prior Labs authentication and licensing process. The current implementation is designed as a small-data prototype and runs on CPU.

Why Does Open Innovation Matter?

Open innovation makes it possible for individual developers and small teams to experiment with powerful machine learning tools without building every component from scratch.

For TinyGuard AI, open-source libraries such as Pandas, Scikit-learn, Matplotlib, and Streamlit provided the foundation for data processing, anomaly detection, visualization, and the application interface.
Integrating TabPFN gave me an opportunity to explore a specialized tabular machine learning model alongside a conventional anomaly detection approach.

Instead of depending entirely on a closed, general-purpose AI API, I could build around tools designed for specific tasks, understand how the components work together, and customize the application for a practical use case.

My First User

One of the first things I wanted to validate with TinyGuard AI was whether someone could upload an expense CSV and understand the results without needing a machine learning background.
The idea is genuinely useful: instead of manually scanning rows of expenses, users can get a quick overview of unusual transactions through Isolation Forest, with a separate TabPFN classification demo.

What could be improved next? I'd want clearer explanations of why a transaction was flagged, an easier way to compare the two models, and testing against real, appropriately labelled data before relying on the results for financial decisions.

For me, the most valuable next step would be making the flagged transactions easier to investigate, rather than simply showing predictions.

Prize Categories

Prior Labs — Best Use of TabPFN: Uses TabPFN for a separate tabular classification demonstration alongside Isolation Forest anomaly detection.

Show your love and support !!!

Cross-Origin Resource Sharing

Dakshata — Wed, 30 Apr 2025 18:55:19 +0000

What is (CORS) Cross-Origin Resource Sharing ?
In simple words, is a mechanism for integrating applications.For example, your application may use your browser to pull videos from a video platform API, use fonts from a public font library, or display weather data from a national weather database. CORS allows the client browser to check with the third-party servers if the request is authorized before any data transfers.

What does "other-domain" means?
means the URL being accessed differs from the location that the JavaScript is running from, by having:

a different scheme (HTTP or HTTPS)
a different domain
a different port

Why do we need CORS?
This is a worst-case scenario, where everything is wide open. But it still exemplifies what a CORS attack looks like. In fact, in 2016, Facebook was found to be vulnerable to such a CORS attack.

One domain + port combination cannot read the response to a request from
a different domain + port combination.

How to allow CORS in react.js?

Using proxy in package.json file.
Add the API part to package.json file.
Then make request :-

React.useEffect(() => {
    axios
        .get('api/profile/')
        .then(function (response) {
            console.log(response);
        })
        .catch(function (error) {
            console.log(error);
        });
});

How to prevent CORS-based attacks?

Specify the allowed origins
Only allow trusted sites
Don’t whitelist “null”
Implement proper server-side security policies

For more information and installation visit - www.npmjs.com

ⓢⓗⓞⓦ ⓛⓞⓥⓔ ⓐⓝⓓ ⓢⓤⓟⓟⓞⓡⓣ

SAYONARA 2024

Dakshata — Tue, 07 Jan 2025 12:20:29 +0000

This is a submission for the 2025 New Year Writing challenge: Retro’ing and Debugging 2024.

New year — a new chapter, new verse, or just the same old story? Ultimately we write it. The choice is ours.
— Alex Morritt

2O24 has been the great year for me, as I stepped into college to pursue my bachelor's degree in computer science and engineering. Missing those school days a lot 🫠. Anyway, I got to learn and experience many futuristic things. Yes!! I participated in Girl Script Summer of Code (GSsoc'24), Hacktoberfest and got selected for Social Winter of Code 2024 ⛄ as a Contributor.

Girl Script Summer Of Code 2024 🚀

Participating in Girl Script Summer of Code 2024 (GSsoC '24) has been an incredible experience that allowed me to grow as a developer while contributing to impactful open-source projects.

Achievements 🌟

7 Pull Requests Merged: Tackled diverse issues across multiple
repositories, focusing on solving real-world problems.
Ranked 177: Among thousands of contributors, I’m proud to have made
meaningful contributions that earned me this rank.
Hacktoberfest 🌱

I had the privilege of participating in Hacktoberfest 2024, and it was an amazing experience that challenged me to push my limits while contributing to meaningful open-source projects.

Achievements 🌟

Completed All 4 Levels: I successfully submitted the required pull requests, earning the recognition of completing all levels of Hacktoberfest.
Early Pegasus Badge: I earned the Early Pegasus Badge by contributing early and actively throughout the month, demonstrating my commitment to open-source.

Last but not the least I think that this is just the beginning. The world of open-source is boundless, and I am excited to continue my journey by contributing, learning, and collaborating on projects. I’m interested in exploring new technologies, refining my skills, and making a lasting impact in the open-source community.

Ⓢⓗⓞⓦ ⓛⓞⓥⓔ💖 ⓐⓝⓓ ⓢⓤⓟⓟⓞⓡⓣ 🙌

BLOCKCHAIN the emerging trend

Dakshata — Sun, 05 Jan 2025 18:09:15 +0000

This is a submission for the 2025 New Year Writing challenge: Predicting 2025.

What is Blockchain?
“Bumble” are rewarded for making successful matches whether it’s dating to freelancing to Ola and Flipkart.
In a simple language, Blockchain is secure digital Technology that creates an unchangeable record of transactions. The global blockchain technology market size was valued at USD 17.46 billion in 2023 and is expected to grow at a compound annual growth rate (CAGR) of 87.7% from 2023 to 2030.

Trend Analysis

It has got Advance Privacy Feature which is the biggest concern in today's era.
Transparency which is the most important factor to grow at rapid pace.
Suitable Environment which made it easier to get accepted by countries like Switzerland and Singapore.
Easy Adoption, BaaS (Blockchain-as-a-Service) enables companies to deploy blockchain Technology without complex infrastructure, easier to handle.

Specific Tools
- Development Frameworks:-
1.Truffle Suite
2.Hardhat
3.Embark
4.Quorum
- Programming Languages:-
1.Solidity
2.Rust
3.Go
4.JavaScript

Companies that use this Technoloy are HSBC, VISA, SIEMENS, Walmart, EHIHAD Airways, British Airways ...and many more.

Show love💖 and support!!🙌

Girl in Tech

Dakshata — Thu, 02 Jan 2025 18:37:35 +0000

GIRL IN TECH
Its Vibrant Community of Girl's 👧 who are passionate about Tech/STEM. Its not just about women in Tech, it's about women building Tech.
Non-Profit Community for Girls who want to excel in their life.

We need diversity of experiences, Perspective, and stories to build a community.
It's important to ensure that the Technology being built serves each and every person.
To build it, is to ensure we have diversity within the coders creating that Technology.

Here what you can expect:-

Support from Other girls from different part of India
Internship/Jobs Alert.
Guidance from Senior's.
Monthly Coffee Chats.
Text + Video Resources.
Info about latest Events/Scholarships .....and Much more

Started back in June 2024 by Manik. Grown to a community of 1200+ girls. 1.2k Newsletter subscriber. Having Phenomenal results in GHC Scholarship, Codess Cafe.
It's not just a community it's an Emotion where everyone connects and build network.

Do Visit [https://www.linkedin.com/company/girls-in-tech-community/posts/?feedView=all]

Show your Love💖 and Support🙌!!!

Social Winter of Code 2025

Dakshata — Thu, 05 Dec 2024 13:36:35 +0000

Here are the things you should know about SWOC-2025

What is SWOC?

Social Winter of Code is an open-source program Which aims to bring students into the world of open-source development and see the power of unified problem-solving in real time. Social Winter of Code is the 2 month long open-source program. Highly Preferred to those who are new into world of coding.

Why Should you participate?

You will be guided on various topics like Web & App development, Frontend/Backend, Web3, Blockchain, Artificial Intelligence, Machine Learning, Personal Branding. Moreover, there are many giveaways, you can also get Swags. You even get contributor Badge to showoff you peers.

What Pre-Requisite Knowledge Required?

If you can have basic Knowledge of Git and GitHub or Git Desktop that would be good. Like basic commands git push, git commit,git pull,git status. But no problem if you don't know. You will get to know about them in this programme.

Ways to Contribute?

There are many ways to contribute to SWOC, and you don't need to be a coding wizard at all. In fact, there are several ways to participate that don’t involve coding at all.

Writing: Contribute by writing or improving documentation.
Graphic Design: Create graphics, icons, and other visual elements that projects may need.

In real open source, you have the right to control your own destiny. - Linus Torvalds

I will encourage you to register and participate in this wonderful Open-source Programme ➡️https://socialwinterofcode.devfolio.co/?ref=8ecbd3b2f6
You Can also join Discord Channel and ask your doubts to mentors, project admins➡️https://discord.gg/bAMqtfsX

Keep Learning, Keep Growing❄️⛄💙!! Yes, don't forget to share with your friends.

DEV Community: Dakshata

LazyLora — Open-Weight Intent, Durable Escalation, Zero Babysitting

What I Built

Demo

Running it locally

Code

the-matrixneo / LazyLora

LazyLore (with Local Open-Weight AI)

Quick Start (with open-weight model)

1. Install & start Ollama

2. Install project dependencies

3. Run the API

4. Test the intent classifier

How I built it

The idea

Architecture

Project layout

Step 1: Open a shift and text the caregivers

Step 2: Let the first "yes" win

Step 3: Escalate with a durable timer

Step 4: Run the worker inside the API

Run it yourself

How the flow works

1. A shift opens (the blue box at the top)

2. The shift is marked PENDING and a timer starts

3. The claim path (green box, left)

4. The escalation path (purple box, right)

Why Temporal for the timer?

What I fixed

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

Red Flags in the Ledger - hf26 Challenge

TinyGuard AI — Simple AI Powered Expense Anomaly Detector

What I Built

Demo

Code

the-matrixneo / spill_the_tea

TinyGuard AI

Quick Start

1. Create & activate a virtual environment

2. Install dependencies

3. Run the app

How to Use

Project Structure

Requirements

How I Built It

Why Does Open Innovation Matter?

My First User

Prize Categories

Cross-Origin Resource Sharing

SAYONARA 2024

Girl Script Summer Of Code 2024 🚀

Hacktoberfest 🌱

BLOCKCHAIN the emerging trend

Girl in Tech

Social Winter of Code 2025

Here are the things you should know about SWOC-2025

What is SWOC?

Why Should you participate?

What Pre-Requisite Knowledge Required?

Ways to Contribute?