DEV Community: juvet manga

I Built a Notion MCP Job Alert Bot to Help My Designer Brother Find Work online from a developing country

juvet manga — Tue, 31 Mar 2026 06:29:14 +0000

(I made this post intially for the Notion MCP challenge but since it is more storydriven I prepared another version to submit and use this one to share to the community, with my back story for building my tool Nancy. Sorry in advance if at some point it sounds like an ad for Notion MCP) - Read the short version here

There's a version of this story where I talk about architecture patterns and API design. I'll get there. But first, let me tell you why this project exists.

My brother is one of the most talented designers I know. We live in Cameroon, work together at a startup that doesn't pay enough yet, and needed side gigs to survive.

We tried Upwork but payments aren't supported in our country, so your earnings just sit there, locked, visible but untouchable.
We tried Fiverr but my brother's account got blocked immediately after we landed our first client, no warning, no reason given. He tried to verify his identity with his national ID card and couldn't, because Fiverr only accepted passports at the time (even though they'd accepted ID cards before). Support never replied by the way.

We spent over two months living on less than $100. Combined.

I decided to stop waiting for platforms to decide our fate. I built Nancy (named after my niece), a service that scrapes Dribbble for new design job postings and sends us a Telegram alert the moment one appears.

The idea was simple: my brother would see job postings before almost anyone else in the world. An edge, however small.

Sad part though, It didn't land us a job (despite being very useful). Most positions required US (or Europe) residency or full-time availability, which we couldn't offer. Hopefully we had a gig with a local company that paid enough for a while.

Anyway it was worth every line of code. I enjoyed fighting fate alongside my brother.

TL;DR: I built a Python bot called Nancy that scrapes Dribbble
job listings and sends Telegram alerts. After adding Notion MCP,
Notion became both the config layer (live settings) and the data
layer (job pipeline tracking). Full source on GitHub.

What Is Nancy? (A Notion MCP-Powered Job Alert Bot)

How It Scrapes and Alerts in Real Time

Nancy is a Python bot that:

Scrapes Dribbble job listings on a schedule
Summarizes each job description using HuggingFace's facebook/bart-large-cnn model
Sends a formatted alert to a Telegram channel with one-tap apply buttons
Tracks everything so the same job is never sent twice

The stack is intentionally lean: Python, FastAPI, BeautifulSoup, and Notion MCP for state management and configuration.

Before Notion, Nancy stored state in flat JSON files and had zero configuration — to change anything you had to redeploy. It worked, but it was not practical.

Hacker note: I used a very interesting tip to get my service working live without ever paying anything. What I did was to use Render.com hosting service to host my app as a web app (Not background or CRON jobs!! These are billed services) and deploy it with an endpoint allowing me to trigger scraping. Then I created an account on the tool Uptime Robot, where I set it to hit my endpoint after every 15 minutes, this way it makes the service stay alive and always act like a live monitoring service.
It is also possible to create a background task service on Render but it's paid, I opted for this free workaround instead (it's got its limitations too but works pretty fine for personal usage). Share me your reviews if you try this tip! 🤓

Video Demo

Using Notion MCP as a Control Plane (Not Just a Destination)

The Notion MCP integration transforms Nancy from a one-trick scraper into a bidirectional job intelligence system. Notion is now both the control plane (Nancy reads its instructions from Notion) and the data layer (every job Nancy finds lives in Notion with full status tracking).

The Config Database: Live Settings Without Redeployment

Most tutorials on Notion MCP show it as an output layer. Nancy flips that.

Nancy reads a live config from a Notion database on every single run:

Setting	Example Value	Effect
`keywords`	`designer, UX, product`	Only alert on jobs matching these terms
`job_types`	`Full-time, Contract`	Filter by employment type
`max_pages`	`3`	How many Dribbble pages to scrape per run
`active`	`true` / `false`	Kill switch — pause Nancy without touching code

Want to focus only on freelance roles this week? Edit one cell in Notion. Want to pause Nancy while you're away? Flip active to false. No redeployment, no code changes, no terminal.

`# Nancy reads this on every trigger
config = notion_tracker.get_config()

if config.get("active", "true").lower() == "false":
return {"status": "paused", "detail": "Nancy is paused via Notion config."}

max_pages = int(config.get("max_pages", 2))
keywords = [k.strip().lower() for k in config.get("keywords", "").split(",") if k.strip()]`

The Jobs Database: A Full Application Pipeline in Notion

Every new job Nancy finds is saved to a Notion database with full metadata:

Job Title, Company, Location, Job Type
Status — New → Notified → Reviewing → Applied → Archived
URL — used for deduplication (no more duplicate alerts)
Summary — the HuggingFace-generated summary
Date Found — when Nancy discovered it
Telegram Sent — checkbox confirming the alert was delivered

The Pipeline Board view turns Notion into a job application tracker. You see every opportunity at a glance, and you move cards as you progress. Nancy handles discovery; you handle decisions.

The Full Flow: From Scrape to Telegram Alert

/trigger-scraper called → read config FROM Notion (active? max_pages? keywords? job_types?) → if active=false → return "paused" → load existing job URLs from Notion (deduplication) → scrape Dribbble up to max_pages → for each new job matching filters: → summarize via HuggingFace API → send Telegram notification → save to Notion (Status=New) → mark Telegram Sent → Status=Notified

New API Endpoints: /config and /jobs

Two new endpoints complete the picture:

GET /config — returns the live Notion config so you can verify what Nancy is running with:

{ "source": "notion", "config": { "keywords": "designer, UX, product", "job_types": "Full-time, Contract", "max_pages": "3", "active": "true" } }

GET /jobs — returns all jobs stored in Notion, filterable by status. Falls back to local JSON if Notion isn't configured.

Tech Stack

Python 3.11 + FastAPI — web service and API
BeautifulSoup4 — Dribbble scraping
HuggingFace (facebook/bart-large-cnn) — job description summarization
python-telegram-bot — Telegram channel notifications
notion-client — official Notion Python SDK
Render — cloud deployment
Notion MCP — control plane + data layer

Why This Architecture Actually Matters

Notion as Source, Not Just Output

Most Notion integrations treat Notion as a destination — a place to dump output. What makes this different is that Notion is also the source. Nancy checks Notion before it does anything. That's the MCP model: your workspace becomes an operating surface, not just a display.

For us, concretely, this means:

My brother can adjust what kinds of jobs Nancy watches for without asking me to redeploy anything
Every lead is tracked in one place, not scattered across Telegram history
The pipeline view makes it obvious which opportunities are worth pursuing

Source Code

The full project is open source: github.com/juv85/Nancy-v2-alt

To run your own instance, clone the repo and set these environment variables:

TELEGRAM_BOT_TOKEN= TELEGRAM_CHANNEL_ID= HF_TOKEN= NOTION_TOKEN= NOTION_JOBS_DB_ID= NOTION_CONFIG_DB_ID=

A .env.example is included as a template.

What's Next: Toward an Autonomous Job Application Agent

I want to be honest: what Nancy does today with Notion is not yet even close to the full power of what MCP makes possible.

Anyway the vision is to build an autonomous job application agent.

With Notion MCP, the agent gains long-term memory. Not just a database of
scraped jobs, but a living context store with an overview of the user's
identity and metadata on jobs that matter to the user.

The agent this way will know what is relevant to highlight when drafting assets to apply, and also what to apply.

Thanks for reading

Juvet Manga

Extras:

Thanks for reading this far.
The story I shared is actually true and you can find my brother's portfolio, website and LinkedIn profile here:

Portfolio: www.dribbble.com/lePerfectionniste
LinkedIn: www.linkedin.com/in/paul-nana-manga/
Website: leperfectionniste-site

If you want high quality work related to design especially in tech (UI/UX for mobile and web apps, Dashboards designs, Pitch-deck slides, brand design etc.) feel free to reach out - leperfectionniste123@gmail.com

📣 Need help with AI for your mobile app ?

As someone who's solved these challenges I offer technical consulting specifically for:

Building Custom Text classification and QA models for mobile apps
NLP model integration in React Native apps
Mobile-optimized AI architecture
AI project ideation and conception

I am also available for freelance gigs related to :

Mobile app development with React Native
Backend development with Django
Web apps development with React
CI/CD setup using Github Actions
n8n setup
AI automation Reach out here - mangajuvet87@gmail.com

Let’s connect:

LinkedIn: https://www.linkedin.com/in/juvet-manga/
X: https://x.com/manga_juvet
Book a free call: https://zcal.co/juvet/30min

Nancy: A Notion-Powered Job Intelligence Bot Built Out of Necessity

juvet manga — Sun, 29 Mar 2026 07:06:58 +0000

This is a submission for the Notion MCP Challenge

What I Built

Nancy is an automated Dribbble job intelligence system. It monitors Dribbble for new design job postings, summarizes them using AI, fires real-time alerts to a Telegram channel, and now, powered by Notion MCP, stores every opportunity in a structured Notion workspace with full application pipeline tracking.

The idea was to give my brother an edge: see a new job posting before almost anyone else in the world, apply immediately, and track the whole pipeline in one place.

Core capabilities:

Scrapes Dribbble job listings on demand via a REST API trigger
Summarizes job descriptions using HuggingFace (facebook/bart-large-cnn)
Sends formatted Telegram alerts with one-tap apply buttons
Stores all jobs in a Notion database with status tracking
Reads its own configuration live from Notion — no redeployment needed to change behavior

Tech stack: Python 3.11, FastAPI, BeautifulSoup4, HuggingFace Inference API, python-telegram-bot, notion-client, deployed on Render.

Video Demo

Show us the code

GitHub: github.com/juv85/Nancy-v2-alt

The Notion integration lives in notion/notion_integration.py. The key entry points:

# scraper/scraper.py — reads live config from Notion on every run
config = notion_tracker.get_config()

if config.get("active", "true").lower() == "false":
    return {"status": "paused", "detail": "Nancy is paused via Notion config."}

max_pages = int(config.get("max_pages", 2))
keywords = [k.strip().lower() for k in config.get("keywords", "").split(",") if k.strip()]

# After scraping, each new job is saved to Notion and marked notified
if notion_tracker.enabled:
    page_id = notion_tracker.add_job(job)
    notion_tracker.mark_telegram_sent(page_id)

To run your own instance, clone the repo and set the environment variables required in the .env.example

How I Used Notion MCP

Most Notion integrations use Notion as a destination — a place to dump output. Nancy uses it as both input and output: Notion is the control plane Nancy reads from, and the data layer Nancy writes to.

Notion as control plane (input)

Nancy reads a Config database in Notion before every single run:

Setting	Example	What it does
`active`	`true` / `false`	Kill switch — pause Nancy without touching code
`keywords`	`designer, UX, product`	Only alert on jobs matching these terms
`job_types`	`Full-time, Contract`	Filter by employment type
`max_pages`	`3`	How many Dribbble pages to scrape per run

Want Nancy to focus on freelance roles this week? Edit one cell in Notion. Want to pause it while you're traveling? Flip active to false. No terminal, no redeployment.

Notion as data layer (output)

[SCREENSHOT: Nancy Jobs database — Pipeline Board (Kanban) with columns New / Notified / Reviewing / Applied / Archived]

Every job Nancy finds is saved to a Jobs database with full metadata and a status workflow:

New → Notified → Reviewing → Applied → Archived

This turns Notion into an actual application tracker. Nancy handles discovery; you handle decisions. The Pipeline Board makes it immediately obvious where each opportunity stands.

The full flow

/trigger-scraper → read config FROM Notion (active? max_pages? keywords? job_types?) → if active=false → return "paused" → fetch existing job URLs from Notion (deduplication) → scrape Dribbble up to max_pages → for each new job matching filters: → summarize via HuggingFace → send Telegram alert → save to Notion Jobs DB (Status = New) → update Status → Notified, tick Telegram Sent

Two new API endpoints complete the picture:

GET /config — returns the live Notion config on demand
GET /jobs — returns all jobs from Notion, filterable by status

What's Next

I want to be honest: what Nancy does today with Notion is not yet even close to the full power of what MCP makes possible.

Anyway the vision is to build an autonomous job application agent.

Notion becomes the agent's long-term memory. Not just a database of scraped jobs, but a living context store with an overview of the user's identity and metadata on jobs that matter to the user.
The agent this way will know what is relevant to highlight when drafting assets to apply, and also what to apply.

Thanks for reading

Juvet Manga

What are attention masks in the context of transformers (GPT, BERT, T5)

juvet manga — Sun, 03 Nov 2024 07:25:39 +0000

Imagine your brain as a supercomputer, constantly flooded with data—sights, sounds, thoughts. Every second, new information bombards us, yet somehow, we avoid being overwhelmed. Our brains don’t process every detail; they focus on what matters and filter the rest. Deep learning models, especially transformer-based ones like GPT and BERT, try to mimic this focus. But in a digital world, how do they know what’s important and what to ignore?

Why Do Transformers Need an Attention Mask?

Imagine sitting in a bar, talking with a friend while other people chat loudly around you. You won’t listen to every conversation. You focus only on the words said by your friend despite the fact that your ears capture the surrounding chats. Your brain creates an ‘attention mask,’ filtering out everything irrelevant.

Transformers have a similar challenge and this is where attention masks step in. An attention mask is a tool that tells the model which parts of the input are relevant (ones to “pay attention to”) and which parts should be ignored (masked out). It’s like a set of invisible markers that highlight where to focus and what to skip.

💁🏾 Can you show a clear example that highlights how attention works in a sentence ?

🧏🏾‍♂️ Sure, check this out

How Attention Masks Work in Practice

Consider the following sentence

"The cat sat q1230jiqowe on 3rk30k1 the mat 1231"

here is how our model will represent the data

Sentence: [The, cat, sat, q1230jiqowe, on, 3rk30k1, the, mat, 1231]
Attention Mask: [1, 1, 1, 0, 1, 0, 1, 1, 0]

In this mask:

1s indicate the model should focus on these tokens because they form the actual sentence.
0s indicate noise or irrelevant tokens that the model should ignore.

I guess you automatically removed the irrelevant characters when reading and focused on the valuable information. That’s it.

In transformers, data is fed into the model in the form of a sequence (like a sentence split into tokens). Not all tokens in the sequence are useful; some may be padding tokens added to create equal-length inputs for batch processing. Attention masks act as a filter to block out these irrelevant tokens.

💁🏾 Pad…

🧏🏾‍♂️ Yes I know, let me explain

Well, models have a particular way of processing data. The model needs all the inputs to have the same length before they can be treated, and this length is set when the model is being trained, it’s called the token length.

In practice, if a model has a token length of 10 for example, it looks like this

Sentence 1: The cat sat on the mat

→ [The, cat, sat, on, the, mat, [PAD], [PAD], [PAD], [PAD]]

Sentence 2: The dog ate the fish and ran to the room before I could realize

→ [The, dog, ate, the, fish, and, ran, to, the, room, before]

This helps the model expect a certain amount of information at a given time, so as to avoid excessive data intake, a bit like a speed limiter. This might be the idea of another article but for now let’s stick to attention masks.

Why Attention Masks Matter

Without attention masks, transformers would process all parts of an input indiscriminately. In practice, this would make the model prone to errors, focusing on irrelevant data and potentially "hallucinating" patterns that don’t exist.

By focusing on key information and ignoring unnecessary parts, attention masks keep models efficient, accurate, and grounded in relevant data.

🤷🏾 I think I got the point now, but how does this help anyone in real-world scenarios ?

💁🏾‍♂️ Well there are many applications but take this one…

Practical Impact of Attention Masks

Think of a voice-controlled virtual assistant that responds to commands like, "Play my favorite song." Often, the audio data is noisy, with background sounds, pauses, or even other conversations nearby. Without an attention mask, the assistant might focus on everything in the audio stream, including background noises and other voices. This could lead to misinterpreting the command or even responding to unrelated words.

For example, if someone says:

"Uh, Alexa, can you uhmm play my favorite song? (kids talking in the background)"

Without an attention mask, the assistant might process every single word, including "uh," “uhmm,” "kids talking in the background," and other irrelevant sounds. This can make it slower to respond or even trigger the wrong action.

With an attention mask, the assistant zeros in on the actual command ("can you play my favorite song?") and filters out the rest. This helps it respond quickly, accurately, and without being thrown off by background noise, providing a much smoother user experience.

iPhone users should be able to relate from the way Siri acts most of the time

Brief Note on Other Mask Types

In addition to attention masks, there are several other types of masks that play important roles in transformer models:

Padding Masks: These masks indicate which tokens in a sequence are padding tokens (usually represented as 0 or a special token). Padding is used to ensure all input sequences in a batch are of equal length. Padding masks help the model ignore these irrelevant tokens during processing, much like attention masks.
Segment Masks: In tasks like question-answering or sentence-pair classification, segment masks distinguish between different segments of input. For instance, in a question-answer pair, one segment might represent the question while the other represents the context. This helps the model understand how to treat different parts of the input relative to one another.
Subword Masks: In models that utilize subword tokenization (like BERT), these masks help identify which parts of the input correspond to actual subwords and which are merely padding or irrelevant. This ensures that the model focuses on meaningful linguistic units.
Future Masks: In autoregressive models like GPT, future masks prevent the model from attending to future tokens in the sequence during training. This ensures that predictions for the next token are based solely on past tokens, maintaining the causal nature of the model.
Token Type IDs: While not a mask in the strict sense, token type IDs indicate the type of token in a sequence. They can be useful for differentiating between multiple sentences or parts of text in tasks that require understanding of context. This is sometimes used interchangeably with segment mask ids, I realized this one when working on with a BERT question-answering model.

Closing Recap

In summary, attention masks are a crucial component of transformer models, enabling them to focus on relevant information while filtering out distractions. Just as our brains prioritize significant data amidst a flood of sensory input, attention masks guide models to pay attention to important tokens and ignore irrelevant ones.

Information Filtering: Just like you filter out background noise when having a conversation, attention masks help models zero in on relevant input, ensuring accurate processing.
Practical Applications: The impact of attention masks is clear in real-world scenarios, such as voice-controlled assistants, where the ability to focus on user commands amidst background chatter is vital for delivering a seamless user experience.
Integration with Other Masks: Attention masks work in harmony with other types of masks, such as padding masks, segment masks, and future masks, all of which contribute to the overall effectiveness of transformer architectures.

By understanding how attention masks function, we can appreciate the sophistication behind models like GPT and BERT, which mimic human cognitive abilities to process and prioritize information. As the field of deep learning continues to evolve, mastering these concepts will empower developers and researchers to build more efficient and accurate AI systems.

🙆🏾‍♀️ Is it finished already ? I still wanted to know some stuffs and ask questions 🙁

🙋🏾‍♂️ Don’t bother, ask your concerns in the comment section or even DM, I’ll do my best to answer

About Me

Hi there! I'm Juvet Manga, a young passionate machine learning engineer specializing in developing cutting-edge AI models for mobile applications. With a focus on deep learning and natural language processing, I strive to bridge the gap between complex technology and everyday understanding.

Currently, I’m working on an exciting project as a member of the startup Mapossa involving transformer models. My goal is to make AI accessible and comprehensible for everyone, whether you're a seasoned developer, a curious business exec or just starting your journey in tech.

In addition to my technical work, I love sharing knowledge through writing and presentations, aiming to simplify advanced concepts for a broader audience. When I'm not coding, you can find me playing games (Legend of Zelda is my favorite😍) or exploring the latest AI research. Let’s connect and explore the fascinating world of AI together !
-> LinkedIn: Juvet Manga
-> X: juvet_manga

Text Classification vs. Token Classification in NLP: Key Differences, Use Cases, and Performance Optimization

juvet manga — Sun, 13 Oct 2024 07:38:28 +0000

With the explosion of Large Language Models (LLMs) like ChatGPT, Gemini, and Claude AI, Natural Language Processing (NLP) has permeated virtually every field. But when building AI models for real-world applications, we often face critical decisions about which NLP tasks best suit our goals. Among these, text classification and token classification stand out as essential tools in the machine learning toolkit, but choosing the right one can dramatically impact model performance and practicality.

While at first glance they may seem similar, these two tasks present very different technical challenges and serve distinct purposes. In this article, we’ll explore their key differences, when to use each, and the technical considerations that can make or break your model in production.

Text Classification: The Straightforward Class Labeling Task

Text classification involves assigning an overall label to a chunk of text, whether it’s a sentence, paragraph, or document. For many, this task is the first step into NLP and one of the more straightforward implementations in machine learning.

There exist 2 types of text classification

Multi-class text classification: Which assigns a unique category to a piece of text. An example is a spam detector model, a message can either be a spam or not a spam but not both at the same time.
Multi-label text classification: Which makes it possible to overlap categories for a specific piece of text. An example of multi-label text classification is a movie genre classifier. A single movie can belong to multiple genres simultaneously, such as "Action", "Sci-Fi", and "Thriller". For instance, the movie "The Matrix" could be classified under all three of these categories at once, demonstrating how categories can overlap in multi-label classification.

However, text classification can become deceptively complex as you scale your models or expand to domain-specific tasks. Let’s take sentiment analysis as an example. While basic models can perform sentiment analysis with high accuracy, challenges arise when:

The text contains ambiguity or sarcasm.
You need the model to handle multilingual data or domain-specific jargon.

An experienced developer or data scientist understands that building a robust text classification model isn’t just about using off-the-shelf architectures. It’s about understanding the trade-offs in choosing architectures like logistic regression, LSTMs, or transformers (like BERT), and optimizing for speed and accuracy depending on the use case.

Example:

Text: "Your service was amazing!"
Model output: Positive sentiment

But what about more complex sentences with multiple meanings, or long-form text where sentiment may shift midway through? This is where text classification can hit its limitations.

Token Classification: Contextual Labeling at the Token Level

Token classification, on the other hand is actually a specialized variation of text classification . It requires labeling each token (word or sub-word) in a sentence, making it more intricate.

This is essential for tasks like Named Entity Recognition (NER), part-of-speech tagging, or even question-answering tasks, where the model needs to understand context at a granular level.

Unlike text classification, where you only care about the overall sentiment or category of the text, token classification requires the model to consider the relationships between words and the semantic dependencies across the entire input.

Example:

Sentence: "Elon Musk founded SpaceX."
Model output: 
- [Elon Musk]: PERSON
- [SpaceX]: ORGANIZATION

For the model to be able to identify SpaceX as an organization, it needs to understand how it relates to the rest of the words in the sentence and this is where the transformer architecture excels (but this concept is for another day).

Token classification tasks become particularly challenging when dealing with domain-specific entities (legal, medical), or when attempting to optimize for both speed and accuracy in production environments.

The Challenges: Data Labeling, Model Complexity, and Performance Trade-offs

For text classification, data labeling is often more straightforward because you’re working at the document or sentence level. But in token classification, data labeling is a far more complex and time-consuming process. Every token in your dataset needs to be carefully labeled, which can quickly escalate the cost and effort involved in preparing your dataset.

Additionally, from an architectural standpoint, token classification models are typically more complex. Transformers like BERT have become the go-to architectures for these tasks due to their ability to handle contextual relationships, but this comes with trade-offs in terms of:

Inference time (especially in real-time applications).
Model size (which can be prohibitive in low-resource environments like mobile).

When to Choose One Over the Other

In reality these tasks are not exactly substitutes, each one solves a very specific problem. Anyway here is what to remember when going for one of these models

Text classification is ideal when you’re analyzing an entire body of text and care about its overall label. Think about tasks like document classification (e.g., spam detection or sentiment analysis).
Token classification should be your choice when you need a more granular understanding of the text, such as in NER, information extraction, or question-answering systems.

Performance Considerations: Scaling and Optimization

When moving models into production, experienced developers will encounter performance bottlenecks, especially with token classification models. For example, token classification tasks often require significant computational resources, making them slower in inference compared to text classification tasks.

In low-latency environments, where speed is crucial (e.g., mobile applications), you might need to:

Quantize your models (especially BERT-based ones) for faster inference.
Employ model distillation to shrink large models without sacrificing too much accuracy.
Consider hybrid models that combine the best aspects of both tasks.

Conclusion: Mastering the Right Tool for the Job

Understanding the key differences between text classification and token classification helps you choose the right approach for your project. Whether you're building a sentiment analysis model to understand customer feedback or implementing NER for contract analysis, your task requires a clear understanding of the technical and architectural trade-offs. By carefully selecting the appropriate model, optimizing for performance, and keeping your end-use case in mind, you can significantly improve the effectiveness and efficiency of your NLP projects.

Final Thought

As machine learning advances, the boundary between text and token classification may continue to blur, but understanding these foundational differences will keep you ahead of the curve—whether you’re optimizing for speed, scalability, or accuracy in real-world applications.

If you found this helpful please let me know in the comments or by leaving a reaction, that motivates me really much to continue.

You can find me on LinkedIn if you want to connect or to collaborate: Here's my profile

DEV Community: juvet manga

I Built a Notion MCP Job Alert Bot to Help My Designer Brother Find Work online from a developing country

What Is Nancy? (A Notion MCP-Powered Job Alert Bot)

How It Scrapes and Alerts in Real Time

Video Demo

Using Notion MCP as a Control Plane (Not Just a Destination)

The Config Database: Live Settings Without Redeployment

The Jobs Database: A Full Application Pipeline in Notion

The Full Flow: From Scrape to Telegram Alert

New API Endpoints: /config and /jobs

Tech Stack

Why This Architecture Actually Matters

Notion as Source, Not Just Output

Source Code

What's Next: Toward an Autonomous Job Application Agent

Extras:

📣 Need help with AI for your mobile app ?

Nancy: A Notion-Powered Job Intelligence Bot Built Out of Necessity

What I Built

Video Demo

Show us the code

How I Used Notion MCP

Notion as control plane (input)

Notion as data layer (output)

The full flow

What's Next

What are attention masks in the context of transformers (GPT, BERT, T5)

Why Do Transformers Need an Attention Mask?

How Attention Masks Work in Practice

Why Attention Masks Matter

Practical Impact of Attention Masks

Brief Note on Other Mask Types

Closing Recap

Further Reading

About Me

Text Classification vs. Token Classification in NLP: Key Differences, Use Cases, and Performance Optimization

Text Classification: The Straightforward Class Labeling Task

Example:

Token Classification: Contextual Labeling at the Token Level

Example:

The Challenges: Data Labeling, Model Complexity, and Performance Trade-offs

When to Choose One Over the Other

Performance Considerations: Scaling and Optimization

Conclusion: Mastering the Right Tool for the Job

Final Thought