Edge Program Week-by-Week Plan

Goal: Become Byte Edge SME for incident management within 4 weeks Time commitment: 10-15 hours/week Support: Christian Manning (weekly check-ins), Byte Edge engineer (async Slack)

Week 1: Concepts & Context (8-10 hours)

Monday-Tuesday: Core Concepts

• [ ] Read 01-edge-computing-overview.md (30 min)
• [ ] Read 02-kubernetes-overview.md (45 min)
• [ ] Take notes on key concepts

Wednesday-Thursday: Telemetry Deep Dive

• [ ] Read 03-telemetry-overview.md (40 min)
• [ ] Read 04-hyperdx-clickhouse.md - ClickStack Deep Dive (50 min)
• [ ] Watch: Introduction to Observability (optional, 20 min)
• [ ] Watch: ClickStack Open House - Tesla, OpenAI, Anthropic use cases (optional, 30 min)

Friday: Consolidation & Planning

• [ ] Review notes from Modules 1-4
• [ ] Schedule 1-hour shadow call with Byte Edge engineer
• [ ] Prepare questions for shadow call
• [ ] Weekly check-in with Christian

Deliverable: List of 5-10 questions about edge architecture for shadow call

Week 2: Local Environment Setup (10-12 hours)

Monday-Tuesday: Environment Preparation

• [ ] Install Docker Desktop, kubectl, kind, helm (2 hours)
• [ ] Read 05-local-demo-setup.md (30 min)
• [ ] Create local Kubernetes cluster (30 min)

Wednesday: Deploy Stack

• [ ] Deploy ClickStack (ClickHouse + HyperDX + OpenTelemetry) (1.5 hours)
• [ ] Deploy sample POS app with OTLP instrumentation (30 min)
• [ ] Troubleshoot any issues

Thursday: First Investigation

• [ ] Complete Exercise 1: Basic Log Investigation with Lucene syntax (30 min)
• [ ] Complete Exercise 2: Trace Analysis with SQL queries (45 min)
• [ ] Practice dual query modes: Lucene for search, SQL for analytics

Friday: Consolidation

• [ ] Document local setup process
• [ ] Take screenshots of HyperDX UI
• [ ] Weekly check-in with Christian

Deliverable: Working local demo environment, screenshots of investigations

Week 3: Hands-On Practice (12-15 hours)

Monday: Intermediate Exercises

• [ ] Complete Exercise 3: Service Dependency Analysis (45 min)
• [ ] Complete Exercise 4: Resource Exhaustion (1 hour)

Tuesday-Wednesday: Advanced Exercises

• [ ] Complete Exercise 5: Cross-Service Investigation (1.5 hours)
• [ ] Complete Exercise 6: Conditional Export (1 hour)
• [ ] Practice kubectl commands, ClickHouse queries

Thursday: Final Challenge

• [ ] Complete Final Challenge: Full Incident Simulation (2 hours)
• [ ] Write mock Post-Incident Review document
• [ ] Practice incident response workflow

Friday: KFC US Lab Access

• [ ] Request access to KFC US lab environment
• [ ] Review KFC US Retool features
• [ ] Document differences between local demo and KFC US lab
• [ ] Weekly check-in with Christian

Deliverable: Completed exercises, mock PIR, access to KFC US lab

Week 4: Real-World Integration (10-12 hours)

Monday-Tuesday: KFC US Lab Exploration

• [ ] Deploy ClickStack in KFC US lab (if not already deployed)
• [ ] Review existing telemetry data
• [ ] Test both SQL and Lucene query modes
• [ ] Identify gaps in current observability

Wednesday: IM Requirements Doc

• [ ] Document what telemetry IM needs for investigations
• [ ] List missing capabilities in current ClickStack setup
• [ ] Define conditional export triggers (edge → Datadog)
• [ ] Document use cases for SQL vs Lucene queries
• [ ] Share draft with Byte Edge engineer

Thursday: Team Training Prep

• [ ] Create ClickStack demo presentation (15-20 min)
• [ ] Include SQL and Lucene query examples
• [ ] Write edge investigation runbook (initial draft)
• [ ] Prepare examples from KFC US lab

Friday: Team Demo & Feedback

• [ ] Present ClickStack demo to Byte IM team
• [ ] Show unified signal correlation (logs → traces → metrics)
• [ ] Gather feedback and questions
• [ ] Update runbook based on feedback
• [ ] Weekly check-in with Christian

Deliverable: IM requirements doc, edge investigation runbook, team training delivered

Option A: Morning Study (1.5-2 hours before work)

• 7:00-7:30 AM: Read one module section
• 7:30-8:30 AM: Hands-on practice (exercises or local demo)
• 8:30-9:00 AM: Document learnings, prepare questions

Option B: Evening Study (1.5-2 hours after work)

• 6:00-6:30 PM: Review notes from previous session
• 6:30-7:30 PM: Hands-on practice
• 7:30-8:00 PM: Read next module section

Option C: Blocked Work Time (during work hours)

• 20-30% of work week (~8-12 hours) blocked for "Edge SME Development"
• Break into 2-hour focused sessions
• Use Pomodoro technique (25 min work, 5 min break)

End of Week 1:

✅ Completed all reading (Modules 1-4) ✅ Shadow call with Byte Edge engineer completed ✅ Can explain edge computing, K8s, ClickStack to a colleague ✅ Understand difference between SQL and Lucene query modes

End of Week 2:

✅ Local ClickStack environment running ✅ Completed first 2 exercises ✅ Can investigate basic incidents using both SQL and Lucene queries

End of Week 3:

✅ Completed all 6 exercises + final challenge ✅ Can query ClickHouse with SQL, use unified signal correlation ✅ Access to KFC US lab environment

End of Week 4:

✅ IM requirements doc completed ✅ Edge investigation runbook (draft) completed ✅ Team training delivered ✅ Recognized as Byte Edge SME for IM

Weekly Check-ins with Christian

Schedule: Every Friday, 30 minutes Agenda:

• Progress review (what you completed this week)
• Challenges and blockers
• Questions and clarifications
• Next week's goals

Byte Edge Engineer (Async)

Communication: Slack When to reach out:

• Technical blockers (can't get HyperDX running, etc.)
• Architecture questions
• Access requests (KFC US lab, repos)

Expected response time: 24-48 hours

Team Support

• Peer review: Share your local demo with another IM team member
• Buddy system: Pair with a teammate for exercises
• Show & tell: Present learnings at team meeting

1. Hands-on > Reading

• Don't just read the modules passively
• Set up the local demo ASAP
• Practice every concept you learn

2. Document Everything

• Take screenshots of HyperDX queries
• Save useful kubectl commands
• Write down "aha!" moments

3. Ask Questions Early

• Don't struggle alone for hours
• Reach out to Byte Edge engineer or Christian
• No question is too basic

4. Connect to Real Work

• Think about current incidents you've handled
• How would edge telemetry have helped?
• Document use cases as you learn

5. Teach to Learn

• Explain concepts to a colleague
• Write a summary in your own words
• Teaching solidifies understanding

Pitfall 1: "I don't have time"

Solution: Block 20-30% of your calendar explicitly for this. Treat it like any other work priority.

Pitfall 2: "I'm stuck on setup"

Solution: Don't spend more than 1 hour troubleshooting alone. Ask for help immediately.

Pitfall 3: "This is overwhelming"

Solution: Focus on one module at a time. You don't need to master everything at once.

Pitfall 4: "I'm not a K8s expert"

Solution: You don't need to be! You need "just enough" K8s for incident management, not to become a platform engineer.

Pitfall 5: "The local demo doesn't work like production"

Solution: That's OK! The goal is to understand concepts and practice workflows, not perfect replication.

By the end of 4 weeks, you should be able to:

Technical Skills:

• [ ] Navigate a K8s cluster with kubectl
• [ ] Query ClickStack using both SQL and Lucene syntax
• [ ] Write ClickHouse SQL queries with native JSON column access
• [ ] Use unified signal correlation (logs → traces → metrics)
• [ ] Identify resource exhaustion issues
• [ ] Trace requests across multiple services
• [ ] Export telemetry from edge to Datadog via OTLP

Incident Management Skills:

• [ ] Investigate store-specific incidents using edge telemetry
• [ ] Correlate edge telemetry with Datadog cloud telemetry
• [ ] Determine if issue is edge, network, or cloud
• [ ] Document findings in a clear, structured way
• [ ] Recommend fixes based on telemetry data

Communication Skills:

• [ ] Explain edge computing to non-technical stakeholders
• [ ] Present ClickStack capabilities to IM team (SQL + Lucene, unified signals)
• [ ] Collaborate with Byte Edge engineer on requirements
• [ ] Write clear runbooks and documentation

Kubernetes

# Get pods
kubectl get pods -n <namespace>

# View logs
kubectl logs <pod> -n <namespace>

# Describe pod (events, config)
kubectl describe pod <pod> -n <namespace>

# Port-forward service
kubectl port-forward -n <namespace> svc/<service> <local-port>:<remote-port>

# Check resource usage
kubectl top pods -n <namespace>

ClickHouse

# Connect to ClickHouse
kubectl exec -it -n observability clickhouse-0 -- clickhouse-client

# Query error logs
SELECT timestamp, service_name, body
FROM default.otel_logs
WHERE severity_text = 'ERROR'
AND timestamp > now() - INTERVAL 1 HOUR
LIMIT 100;

# Query slow traces
SELECT trace_id, max(duration_ns / 1000000) AS max_duration_ms
FROM default.otel_traces
WHERE timestamp > now() - INTERVAL 1 HOUR
GROUP BY trace_id
HAVING max_duration_ms > 1000
ORDER BY max_duration_ms DESC;

ClickStack UI (HyperDX)

• Unified Search: Query logs, metrics, and traces in one view
• Lucene mode: Simple text search (e.g., error payment service:payment-service)
• SQL mode: Powerful analytics (e.g., SELECT service_name, count(*) FROM logs GROUP BY service_name)
• Traces: Sort by duration, filter by status, view waterfall
• Metrics: Create dashboards, set alerts, visualize trends
• Correlation: Click log → see trace, click trace → see related logs

Use this checklist to track your progress:

Week 1:

• [ ] Module 1 completed
• [ ] Module 2 completed
• [ ] Module 3 completed
• [ ] Module 4 completed
• [ ] Shadow call completed

Week 2:

• [ ] Local demo environment running
• [ ] Exercise 1 completed
• [ ] Exercise 2 completed

Week 3:

• [ ] Exercise 3 completed
• [ ] Exercise 4 completed
• [ ] Exercise 5 completed
• [ ] Exercise 6 completed
• [ ] Final challenge completed
• [ ] KFC US lab access obtained

Week 4:

• [ ] IM requirements doc completed
• [ ] Edge investigation runbook drafted
• [ ] Team training delivered
• [ ] 5+ team members can use HyperDX basics

Q2 2026: KFC US Edge Readiness

• Support KFC US edge deployment
• Refine HyperDX setup based on real usage
• Document edge-specific incident patterns
• Train IM team on edge investigations

Q3 2026: UK Edge Expansion

• Lead edge readiness for UK deployment
• Adapt learnings from KFC US
• Create region-specific runbooks

Q4 2026: Australia & Beyond

• Support Australia edge deployment (stretch goal)
• Become go-to expert for edge incidents across IM team
• Mentor new team members on edge

Merit badges for progress:

• 🏅 Week 1: Edge Computing Fundamentals
• 🏅 Week 2: Local Environment Setup
• 🏅 Week 3: Hands-On Investigation
• 🏅 Week 4: Real-World Application
• 🏅 Q2 2026: KFC US Edge Support
• 🏅 Q3 2026: UK Edge Support
• 🏅 Q4 2026: Byte Edge SME (Certified)

This upskilling aligns with Goal 5.1: Professional development (2-3 team members through training programs).

This is a stretch, but you've got this!

You're not expected to become a Kubernetes or platform engineering expert. You need "just enough" edge knowledge to effectively investigate incidents and collaborate with the Byte Edge team.

Focus on:

• Understanding concepts (why edge? why ClickStack? SQL vs Lucene?)
• Practicing incident investigation workflows
• Building muscle memory with kubectl and ClickStack
• Learning when to use SQL (analytics) vs Lucene (exploration)
• Leveraging unified signal correlation (logs → traces → metrics)
• Documenting IM requirements for edge telemetry

Don't worry about:

• Writing Helm charts or Kubernetes manifests
• Deep networking or storage configuration
• Becoming a ClickHouse DBA or query optimization expert
• Knowing every kubectl command
• Mastering every ClickStack feature (focus on core investigation workflows)

You're resourceful, technically adaptive, and have Claude as a copilot. You'll do great!

Questions? Reach out to Christian Manning or Byte Edge engineer.

Ready to start? Begin with 01-edge-computing-overview.md!

🚀 Let's go!