👋 Build an AI Onboarding Buddy Bot in Slack for New Engineers

New-hire onboarding at most companies is a stale wiki page and a kind teammate who answers the same questions every Monday. When we hired three engineers in a month, I got tired of being that teammate. So I built an onboarding buddy bot: it greets each new hire, walks them through setup at their own pace, and answers the small questions that would otherwise interrupt someone. The AI tailored the path to each role, but I made sure a human had reviewed every step before the bot ever said hello.

What the bot needs to do

Onboarding is a checklist with judgment. A backend engineer needs database access and the local stack running; a data engineer needs the warehouse and the dbt repo. The bot’s job is to present the right checklist, track progress, and answer “how do I actually do step 4?” without a person in the loop for every question. That is two capabilities: a stateful checklist living in the App Home tab, and a conversational helper grounded in our setup docs.

The App Home as a checklist

The App Home tab is the bot’s front door. When a new hire opens the app, they see their personalized checklist with checkboxes that persist. I publish the view on app_home_opened:

const { App } = require("@slack/bolt");
const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET,
});

app.event("app_home_opened", async ({ event, client }) => {
  const profile = await getNewHireProfile(event.user);
  await client.views.publish({
    user_id: event.user,
    view: buildChecklistView(profile),
  });
});

The checklist is just a list of section blocks with a button per step:

function buildChecklistView(profile) {
  return {
    type: "home",
    blocks: profile.steps.flatMap((step) => [
      {
        type: "section",
        text: { type: "mrkdwn", text: `${step.done ? "✅" : "⬜"} *${step.title}*\n${step.detail}` },
        accessory: step.done
          ? undefined
          : { type: "button", text: { type: "plain_text", text: "Mark done" }, action_id: `done_${step.id}` },
      },
      { type: "divider" },
    ]),
  };
}

Tailoring the path with AI

The role-specific ordering is where the model helps. Given a base list of onboarding tasks and the new hire’s role and team, I ask the model to order and lightly customize the steps. The model is a fast junior coordinator here: good at sequencing, not the author of policy.

const prompt = `Order these onboarding steps for a ${role} on the ${team} team.
Put blocking prerequisites first. Keep every step; do not invent new ones.
Return a JSON array of step ids in order.

Steps:
${JSON.stringify(baseSteps)}`;

Crucially, the model reorders a fixed set of steps. It cannot add a step that grants access or skips a security review, because the menu it chooses from was written and approved by a human. The AI personalizes; it does not invent policy.

Pro Tip: Cache the generated order per role, not per person. New hires in the same role get the same vetted sequence, which means you review each role’s path once instead of trusting a fresh generation for every hire.

The conversational helper

When a new hire DMs the bot “how do I get database access?”, it answers from our setup docs using the same retrieval-then-generate pattern I use for FAQ bots: pull the relevant doc chunk, hand it to the model, and answer with a link. If the docs do not cover it, the bot tags their assigned buddy instead of guessing.

app.message(async ({ message, client }) => {
  if (message.channel_type !== "im") return;
  const answer = await answerFromOnboardingDocs(message.text);
  await client.chat.postMessage({
    channel: message.channel,
    blocks: answer.blocks,
    text: answer.fallback,
  });
});

I built and tuned that answer prompt in the prompt workspace against real first-week questions, then saved the working version to prompts. The onboarding and docs-Q&A templates in the prompt packs gave me a head start.

Tracking progress

The “Mark done” buttons update state and re-publish the home view:

app.action(/done_.+/, async ({ ack, body, action, client }) => {
  await ack();
  const stepId = action.action_id.replace("done_", "");
  await markStepDone(body.user.id, stepId);
  const profile = await getNewHireProfile(body.user.id);
  await client.views.publish({ user_id: body.user.id, view: buildChecklistView(profile) });
});

A manager can glance at a summary of who is where, which surfaces a stuck new hire before their second week goes sideways.

Human review before the first hello

I did not let this bot greet anyone until a teammate and I had walked through a full onboarding as a fake new hire. We caught two doc answers that were out of date and one step ordering that put “request VPN” after “clone the private repo,” which is impossible. The principle holds across every bot I ship to a real workspace: AI drafts the experience, a human signs off before it touches a person. A bad onboarding bot does not just annoy; it sets a new hire’s first impression of how the team operates.

Security and tokens

The App Home and DM handlers run behind a public Events API endpoint, so every inbound request gets its signature verified. Bolt checks the X-Slack-Signature HMAC and the request timestamp on each call; if you hand-roll the endpoint, do that yourself and reject anything older than five minutes. The bot token lives in an environment variable and never reaches the model. The model sees role names and doc text, not credentials.

For building this, I used GitHub Copilot for the Bolt action handlers and Claude for the step-ordering and answer prompts, reviewing each. The broader ops-bot patterns are in the Slack category.

Conclusion

An onboarding buddy bot turns a stale wiki and an overloaded teammate into a guided, role-aware first week. Keep the checklist stateful in the App Home, let the model personalize a fixed and vetted set of steps, ground the helper in real docs, and review the whole experience as a fake new hire before it greets anyone. Verify every inbound signature and keep tokens away from the model. Done right, the bot makes a new engineer feel expected instead of lost.