Skill.re
Ai Powered Self Service Portal
Overview
Users open a support portal. Instead of submitting a ticket to a queue and waiting 2 hours, they:
- Describe their problem in plain language
- AI understands what they're asking for
- AI finds the right knowledge article
- If the article doesn't help, AI suggests guided troubleshooting steps
- If still stuck, AI can auto-resolve simple issues (like password resets) or create a ticket with all context pre-populated
The user gets help in minutes instead of hours. The help desk handles only the complex cases. Everyone wins.
This lesson teaches you to build a self-service portal powered by AI: intent recognition, knowledge retrieval, guided troubleshooting, and smart escalation.
Purpose
Help desk costs money. Every ticket processed by a human agent costs $15-50 depending on complexity. Self-service costs nearly nothing (just server/AI inference costs).
If you can deflect 50% of tickets to self-service, you cut help desk costs in half. Most organizations can deflect 50-70% with a well-designed self-service portal.
This lesson covers the architecture: user request → intent recognition → knowledge retrieval → response generation → action execution.
Why This Matters
A financial services company with 5000 employees had 1000 help desk tickets per month. Cost: $20k/month (at $20/ticket average). Plus 2-3 day wait time for users.
They implemented an AI self-service portal. After 3 months:
- Deflection rate: 45% of tickets (450/month)
- Help desk cost: $12.5k/month (down from $20k)
- User wait time: Immediate help (or <1 hour for escalated tickets)
- Help desk satisfaction: Up (they handle only interesting cases)
- User satisfaction: Up (faster help)
Annual savings: $90k (cost) + productivity gains from faster resolution.
Core Concepts
Key insight: Self-service has four steps
Step 1: Intent Recognition
User types: "I can't log into the system"
AI understands: This is a login/authentication problem
Extracts intent: "help_login" or "authentication_issue"
Step 2: Knowledge Retrieval
AI searches knowledge base: What articles match "authentication_issue"?
Results:
- "Forgot password? Here's how to reset"
- "Why am I locked out?"
- "Multi-factor authentication: Setup and troubleshooting"
- "Browser compatibility: Supported browsers for our system"
Ranks results by relevance to the user's problem.
Step 3: Response Generation
Present the most relevant article.
If it answers the question → Done (user self-resolved)
If it doesn't answer → "This article didn't help. Let me try something else."
Step 4: Action Execution (if applicable)
If the issue is password reset → Auto-reset, send email
If the issue is account unlock → Auto-unlock
If the issue requires escalation → Create ticket with full context
Key insight: Knowledge base is critical
A good self-service portal requires:
- Comprehensive knowledge base (answers to 80%+ of common issues)
- Well-organized (users can find answers easily)
- Searchable (AI can find relevant articles)
- Up-to-date (reflects current system state, not outdated info)
If your knowledge base is thin (50 articles for 5000 users), self-service won't work.
If your knowledge base is comprehensive (500+ articles), self-service can deflect 50%+.
Key insight: Guided troubleshooting walks users through problems
Some issues can't be solved by reading an article. The user needs step-by-step guidance.
Example: "Can't connect to WiFi"
AI: "I see you're having WiFi trouble. Let me guide you through troubleshooting.
First, can you tell me: Is the WiFi network showing up in your available networks?"
User: "Yes, it shows up but I can't connect."
AI: "Got it. Let's try:
Step 1: Forget the network (click settings → WiFi → Forget)
Step 2: Reconnect (click the network name, enter password)
Did that work?"
User: "No, still not working."
AI: "Okay, let's try more advanced steps:
Step 3: Restart your computer
Step 4: Restart your WiFi router (unplug for 30 seconds)
Did that work?"
User: "Still no."
AI: "It looks like this needs more investigation. Let me connect you with our support team.
I'm creating a ticket with all the troubleshooting steps we tried.
Support will follow up within 1 hour."
Key insight: Escalation to human is intelligent, not dumb
If self-service can't solve the problem, escalate. But escalate smartly:
- Include all context (what the user tried, what they found)
- Route to the right team
- Prioritize based on impact
Example: Escalation ticket
User tried:
- Password reset (didn't work)
- Account unlock (didn't work)
- Browser change (didn't work)
AI assessment: This is not a simple password/permissions issue.
Likely account corruption or directory service issue.
Needs DBA or admin investigation.
Escalation ticket (auto-created):
- Subject: "Can't login despite password reset attempts"
- Context: [Full conversation with user, steps tried, results]
- Suggested team: DBA team
- Urgency: Medium (user can't work, but no data loss or security risk)
- SLA: 4 hours
Key insight: Feedback loops improve portal over time
Track what happens in self-service:
- What did users ask for?
- What solutions were suggested?
- Did they work?
- Did users escalate?
Analytics:
- Users asking: "How do I reset my password?" → Offered article → Resolved 98% (good)
- Users asking: "Why is my application slow?" → Offered articles → Resolved 30% (bad)
Action: Create more detailed troubleshooting for performance issues
- Users asking: "How do I access the billing system?" → Offered knowledge base → Resolved 40%
Check: Are we answering the right question, or is the knowledge incomplete?
Found: Billing system has 5 different access levels, users confused about permissions.
Need better documentation on permission hierarchy.
Update knowledge base. - Escalation rate by issue type:
Password reset: 2% escalation (good, mostly self-resolved)
Network issue: 45% escalation (bad, knowledge base not comprehensive enough)
Software install: 60% escalation (bad, complex approval process, need better guidance)
Practical Use Cases
Use Case 1: Self-Service Portal Architecture
USER INTERFACE
├─ Search bar: "What do you need help with?"
├─ Chat interface: Conversational Q&A
├─ Guided troubleshooting: Step-by-step walkthroughs
└─ Submit ticket: Escalate to human
STEP 1: Intent Recognition (NLP)
Input: User text (e.g., "I can't log in")
Analysis:
- Tokenize: ["I", "can't", "log", "in"]
- Lemmatize: ["I", "not", "log", "in"]
- Extract entities: action="login", sentiment="problem"
- Classify intent: "authentication_issue" (92% confidence)
Output: Intent + confidence + extracted parameters (username, error message if provided)
STEP 2: Knowledge Base Search (Vector search)
Input: Intent "authentication_issue"
Search: Find KB articles matching this intent
Results ranked by:
- Relevance score (does article match the intent?)
- Popularity (are other users finding this helpful?)
- Recency (was the article updated recently?)
Top results:
1. "I forgot my password" (95% relevance, very popular, updated yesterday)
2. "My account is locked" (85% relevance, popular)
3. "Multi-factor authentication setup" (70% relevance)
STEP 3: Response Generation (LLM)
Context: User intent + top knowledge articles
Generate: Conversational response
Response: "I understand you're having trouble logging in. This is usually caused by:
1. Forgotten password (most common)
2. Account being locked
3. Multi-factor authentication issues
Let me show you the most common solution first.
[Article: How to reset your password]
... (article content)
Did this help? [Yes] [No]"
STEP 4: Feedback & Escalation
If user says "Yes": Mark as resolved, update analytics
If user says "No":
- Offer next solution
- If after 2-3 attempts still not resolved: Escalate
- Create ticket with full context
- Route to right team
TICKET ESCALATION (Auto-created)
Subject: "Can't log in (unable to resolve via self-service)"
Priority: High (user blocked)
Context: [Full conversation]
Suggested team: Authentication team
SLA: 2 hours
EXAMPLE CONVERSATION:
User: "I can't log in"
AI: "I understand you're having login trouble. Let me help.
Is this because:
A) You forgot your password
B) You forgot your username
C) Something else?
Or, describe what happens when you try to log in."
User: "I forgot my password"
AI: "No problem! Here's how to reset your password:
Step 1: Go to the login page
Step 2: Click 'Forgot password?'
Step 3: Enter your username or email
Step 4: You'll get an email with a reset link
Step 5: Click the link and create a new password
Here's more detailed help if you need it: [Link to KB article]
Let me know if you were able to reset your password. [Yes] [No]"
User: [Clicks Yes]
AI: "Great! You're all set. If you need any other help, just ask.
Have a great day!"
ALTERNATIVE CONVERSATION (Escalation):
User: "I can't log in"
AI: "I understand. When you try to log in, what happens?
A) You see an error message (describe it)
B) The page doesn't load
C) You forgot your password
D) Something else"
User: "I see an error 'Account suspended'"
AI: "I see. Your account appears to be suspended.
This usually happens when:
- Password hasn't changed in 90 days (reset required)
- Account locked due to security policy
- Manual suspension by admin
Let me try the most common fix first:
[Send password reset email]
Did that work? [Checking...]
If not, I'll connect you with our admin team.
This might take a few hours to resolve, but you'll be back up soon."
User: "Still doesn't work"
AI: "Okay, I'm creating a support ticket with our admin team.
They'll investigate why your account is suspended.
Ticket #INC-12345 created.
Expected resolution: 4 hours
We'll email you when it's resolved.
In the meantime, is there anything else I can help with?"
Use Case 2: Knowledge Base Optimization
You have a self-service portal, but you don't know which articles are helping vs. which are outdated.
Analytics (Monthly Review):
Article performance:
- "Password reset" (5000 views) → 2000 resolved (40% resolution rate)
- "WiFi troubleshooting" (1000 views) → 150 resolved (15% resolution rate)
- "How to install Slack" (500 views) → 475 resolved (95% resolution rate)
- "Database performance tuning" (50 views) → 5 resolved (10% resolution rate)
Interpretation:
- Password reset: Good article, high traffic, good outcomes. Keep it.
- WiFi troubleshooting: High traffic, LOW resolution rate (15%).
Problem: Article is outdated (recommends old router config)
Action: Update article with current WiFi standard
Re-measure: Resolution rate should improve to 50%+
- Slack install: Excellent (95% resolution rate). Keep it. Maybe feature it more.
- Database tuning: Low traffic, low resolution.
Problem: Article is complex, users are confused
Action: Simplify article, add step-by-step guide
Or: This is a niche topic, fine to have low resolution rate
Escalation analysis:
- Issues escalated before trying self-service: 5% (good, most users try self-service)
- Issues escalated after trying self-service: 25% (medium, expected)
- Issues in self-service but unresolved: 20% (this is the opportunity)
Unresolved issues analysis:
- Users trying "Account permissions" article → 70% escalate
Problem: Article doesn't answer "How do I get access to X?"
Action: Rewrite article with specific step-by-step for permission requests
- Users trying "Software install" guide → 50% escalate
Problem: Process requires manager approval, not self-service fixable
Action: Clarify article: "Self-service for standard software.
Custom or expensive software needs manager approval."
Create escalation ticket with full context.
KB improvement roadmap:
Priority 1: Fix WiFi article (high traffic, low resolution)
Priority 2: Rewrite permissions article (high escalation)
Priority 3: Enhance software install guidance
Priority 4: Simplify database tuning article
Expected impact:
- WiFi article: 1000 views, 15% → 50% resolution = 350 more self-resolved per month
- Permissions article: 800 views, 30% → 70% resolution = 320 more self-resolved per month
- Total: ~670 more tickets self-resolved per month
- Cost savings: 670 × $20 = $13,400/month = $160k/year
Anti-Patterns
Anti-Pattern 1: "We built self-service without a knowledge base"
You deploy a self-service portal without investing in KB articles. The portal tries to help users, but there's nothing useful in the knowledge base. Users get non-answers and have to escalate anyway.
Result: Self-service portal used by 5% of users (those who happen to find relevant content). 95% go straight to ticketing queue.
Why it fails: Self-service depends on having good answers available.
How to avoid it: Before deploying self-service, populate KB with answers to your 80% of common issues. This takes time upfront, but it's the foundation for effective self-service.
Anti-Pattern 2: "We deployed self-service and never maintained it"
You build a great self-service portal. After 3 months, it works well. Then you move on to other projects. The knowledge base becomes stale. Articles reference old systems, outdated procedures, deprecated software.
Users follow the old procedures, get confused, escalate.
Why it fails: Knowledge bases go stale when they're not maintained.
How to avoid it: Assign KB ownership. Review articles quarterly. Update articles after major system changes. Track article performance (resolution rate) and improve low-performing articles.
Anti-Pattern 3: "Escalation tickets don't have context"
Users try self-service, it doesn't work, they escalate to human. But the escalation ticket is empty ("Help, I need something"). The human support team has no context on what the user already tried.
Result: Support team asks the same questions the self-service portal already asked. Repeat work, repeat frustration.
Why it fails: Context is lost in escalation.
How to avoid it: When escalating from self-service, include:
- Full conversation history (what did user ask, what did AI suggest)
- What steps did user try (what solutions worked/didn't work)
- What is user's current state
- Suggested next steps
With this context, support team starts from where the user left off, not from the beginning.
Anti-Pattern 4: "We're not measuring self-service effectiveness"
You deploy self-service portal. But you don't track:
- How many issues are resolved vs. escalated?
- What % of tickets are handled by self-service vs. humans?
- Is resolution rate improving or getting worse?
Without measurement, you can't improve.
Why it fails: You can't improve what you don't measure.
How to avoid it: Track:
- Deflection rate: What % of users that start with self-service resolve without escalating?
- Resolution rate by issue type: What % of WiFi issues are resolved? Password resets?
- Article performance: Which articles lead to resolution? Which lead to escalation?
- User satisfaction: Do users rate self-service as helpful?
Review metrics monthly. Improve low-performing areas.
Anti-Pattern 5: "Self-service tries to handle everything"
You try to solve every possible problem with self-service. You spend months building guided troubleshooting for complex issues. The system becomes bloated and confusing.
Users get lost in the decision trees. Most end up escalating anyway because the guided troubleshooting is too complex.
Why it fails: Self-service is best for simple, common issues (password reset, how-to questions). For complex issues, guided troubleshooting can help but shouldn't be the primary resolution path.
How to avoid it: Prioritize issues:
- High volume, low complexity → Self-service can definitely solve this
- High volume, medium complexity → Self-service can help, but escalation path is needed
- Low volume, high complexity → Skip self-service, escalate directly
Invest effort where you get the highest ROI (high volume, low complexity).
Human Judgment Checkpoints
Knowledge base quality: Is the KB comprehensive? Can users find answers to common issues?
Deflection rate: What % of users who start with self-service get resolved without escalating? Target: 50%+
Escalation quality: When users escalate from self-service, does the ticket have full context?
Article performance: Can you identify which articles have high resolution rates vs. low rates?
User satisfaction: Do users rate self-service as helpful? (NPS or CSAT score)
Key Takeaways
Build a comprehensive knowledge base first. Self-service only works if users can find answers. Invest in KB before deploying self-service.
Recognize intent accurately. Use NLP to understand what users are asking for. If you guess wrong, everything downstream fails.
Retrieve relevant knowledge. Search your KB by relevance, not just keyword matching. Surface the most helpful articles first.
Escalate intelligently with context. When self-service can't help, escalate to humans with full conversation history. Don't make humans re-ask all the questions.
Track what works and what doesn't. Measure resolution rates by issue type. Improve low-performing articles quarterly.
Start simple, expand gradually. Self-service password resets, account unlocks, how-to guidance. Once you nail these, tackle more complex issues.
Prioritize by volume and complexity. Focus first on high-volume, low-complexity issues (biggest ROI). Then tackle high-volume, medium-complexity.