DEV Community: Igor Araujo

How I built a Slack bot in 5 days (OAuth sucked!)

Igor Araujo — Mon, 27 Jul 2026 14:35:38 +0000

I spent a week building a Slack bot that turns conversations into a searchable knowledge base. The AI part (detecting Q&A, extracting answers) took about two days. The Slack integration part? Four days. Here's why, and how to avoid the same traps.

The idea

Slack is where most team knowledge lives, but it's terrible at retrieval. You remember someone answered a question six months ago, but finding it means scrolling through thousands of messages. I wanted a bot that would:

Listen for Q&A patterns in channels
Extract the question and the best answer
Store them in a searchable knowledge base
Let you query it with a slash command: /slacksays "how do we handle refunds?"

Day 1-2: The Slack OAuth flow (the hard part)

Slack OAuth 2.0 has a specific dance for lack of better words:

User clicks "Add to Slack" on your website
They're redirected to Slack's authorization page
After approving, Slack redirects back to your callback URL with a temporary code
Your server exchanges the code for a permanent access token
You now have a token scoped to that workspace

The tricky part is step 4 , the token exchange has to happen server-side, and you need to handle token refresh, workspace-unique tokens, and the fact that each Slack workspace is its own isolated auth.

# Flask OAuth callback
@app.route("/slack/oauth")
def slack_oauth():
    code = request.args.get("code")

    # Exchange code for token
    resp = requests.post("https://slack.com/api/oauth.v2.access", data={
        "client_id": SLACK_CLIENT_ID,
        "client_secret": SLACK_CLIENT_SECRET,
        "code": code,
        "redirect_uri": "https://slacksays.com/slack/oauth"
    })

    token_data = resp.json()
    access_token = token_data["access_token"]
    team_id = token_data["team"]["id"]

    # Store per-workspace
    db.save_token(team_id, access_token)

    return redirect(f"/dashboard?team={team_id}")

Day 3: Event subscriptions

Slack uses a challenge-response for event URL verification. When you set up event subscriptions, Slack sends a POST with a challenge parameter , your endpoint must return it exactly to prove you control the URL.

@app.route("/slack/events", methods=["POST"])
def slack_events():
    data = request.json

    # URL verification challenge
    if data.get("type") == "url_verification":
        return jsonify({"challenge": data["challenge"]})

    # Handle real events
    if data.get("event", {}).get("type") == "message":
        handle_message(data["event"])

    return jsonify({"ok": True})

Day 4: Q&A detection logic

This is where the actual product logic lives. I keep it simple , look for messages that end with a question mark, then find the first reply that looks like an answer (longer than 50 chars, from a different user).

def detect_qa_pair(channel_messages: list) -> dict | None:
    """Find the most recent Q&A pair in a channel."""
    for i, msg in enumerate(channel_messages):
        if msg["text"].strip().endswith("?") and len(msg["text"]) > 20:
            # Look for an answer in the next few messages
            for j in range(i + 1, min(i + 5, len(channel_messages))):
                reply = channel_messages[j]
                if reply["user"] != msg["user"] and len(reply["text"]) > 50:
                    return {
                        "question": msg["text"],
                        "answer": reply["text"],
                        "channel": msg["channel"],
                        "timestamp": msg["ts"]
                    }
    return None

Day 5: Slash command + web dashboard

The /slacksays slash command triggers a search across stored Q&A pairs:

@app.route("/slack/commands", methods=["POST"])
def slash_command():
    query = request.form.get("text", "")
    results = search_knowledge_base(query)

    if not results:
        return jsonify({"text": "No answers found. Try rephrasing your question."})

    blocks = []
    for r in results[:3]:
        blocks.append({
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": f"*Q:* {r['question']}\n*A:* {r['answer'][:300]}"
            }
        })

    return jsonify({"blocks": blocks})

What I'd do differently

The OAuth flow is unforgiving , one misconfigured redirect URL and nothing works. If I were starting fresh, I'd use a framework that handles the Slack OAuth dance out of the box. Flask is great, but wiring Slack auth manually took two full days I could've spent on product.

The bot itself has been running for a few weeks now at slacksays.com. Teams seem to love it , turns out everyone has the same "where did we discuss X?" problem.

*I packaged the Slack bot boilerplate (Flask, OAuth flow, slash commands, event listeners) into a starter kit: [Slack Bot Starter on Gumroad if anyone wanna take a look.

How I built a SaaS in 2 hours

Igor Araujo — Mon, 27 Jul 2026 14:31:27 +0000

So, I've built a few SaaS products over the last year, and the part that always takes the longest isn't the product, it's the plumbing. Auth, billing, database, dashboard, the stuff every SaaS needs before you write a single line of business logic.

For anyone who cares; I stripped my production stack down to the essentials and turned it into a repeatable setup. Here's exactly what it looks like and how long each piece takes.

The stack

Next.js 14 with App Router + TypeScript
NextAuth v4 , email/password + Google OAuth
Stripe , subscription checkout + customer portal
Prisma , type-safe ORM with PostgreSQL
Tailwind CSS , utility-first styling

Minutes 0-30: Auth

Email/password auth with NextAuth takes about 20 minutes if you've done it before. Google OAuth adds another 10. The key is setting up the Prisma adapter so user sessions persist across restarts.

// app/api/auth/[...nextauth]/route.ts
import NextAuth from "next-auth";
import GoogleProvider from "next-auth/providers/google";
import CredentialsProvider from "next-auth/providers/credentials";
import { PrismaAdapter } from "@auth/prisma-adapter";
import { prisma } from "@/lib/prisma";

export const authOptions = {
  adapter: PrismaAdapter(prisma),
  providers: [
    GoogleProvider({ clientId: process.env.GOOGLE_CLIENT_ID!, clientSecret: process.env.GOOGLE_CLIENT_SECRET! }),
    CredentialsProvider({ /* email + password */ }),
  ],
};

Minutes 30-60: Database + Schema

Prisma makes this fast. Define your models in schema.prisma, run npx prisma db push, and you have a working database.

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
  accounts  Account[]
  sessions  Session[]
}

model Account {
  id                String  @id @default(cuid())
  userId            String
  type              String
  provider          String
  providerAccountId String
  // ... standard NextAuth fields
}

Minutes 60-90: Stripe Billing

The Stripe integration has two parts: the checkout session (when a user upgrades) and the customer portal (when they manage their subscription).

// app/api/stripe/checkout/route.ts
import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function POST(req: Request) {
  const { userId, priceId } = await req.json();
  const session = await stripe.checkout.sessions.create({
    mode: "subscription",
    line_items: [{ price: priceId, quantity: 1 }],
    success_url: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard?success=true`,
    cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/pricing`,
    metadata: { userId },
  });
  return Response.json({ url: session.url });
}

The webhook handler listens for checkout.session.completed and updates the user's subscription status in Prisma. That's it , no custom billing logic needed.

Minutes 90-120: Dashboard + Landing Page

The last 30 minutes is UI. A responsive landing page, a pricing table that calls the checkout endpoint, and a dashboard that shows subscription status. Tailwind makes this fast, I use a utility-first approach and build components inline.

// app/dashboard/page.tsx
export default async function Dashboard() {
  const session = await getServerSession(authOptions);
  const user = await prisma.user.findUnique({ where: { email: session.user.email } });
  const isPro = user?.subscriptionStatus === "active";

  return (
    <div className="max-w-4xl mx-auto p-8">
      <h1 className="text-2xl font-bold">Welcome, {user.name}</h1>
      {isPro ? <ProFeatures /> : <UpgradePrompt />}
    </div>
  );
}

The result

Two hours from npx create-next-app to a working SaaS with auth, billing, and a dashboard. The boilerplate isn't glamorous, but it's the foundation every product sits on.

I use this exact stack for my invoicing SaaS (invokepay.com) and it's been running in production for months without issues.

*I packaged this exact stack as a starter kit: [Next.js SaaS Starter] on Gumroad if anyone is interested.