CoderRange - AI , Big data , Data Science !.

### 1. Coding Challenge: Build a Dynamic Form with Validation & Reusability (25 mins)

Objective: Implement a dynamic form component in React that accepts JSON schema and renders inputs with built-in validation.
Key Concepts:

• Controlled components and form state
• Reusable components with props and context
• Validation (custom + libraries like Yup)

Discussion Points:

• Schema-driven UI design
• Managing deeply nested form data
• Performance with large forms (memoization, virtualization)

***

### 2. Debugging Simulation: Resolving React Memory Leaks (25 mins)

Scenario: A React dashboard gradually slows down and crashes after prolonged use.
Tasks:

• Identify and fix memory leaks from event listeners, intervals, or subscriptions
• Apply cleanup with `useEffect` and test with Chrome DevTools

Key Concepts:

• React lifecycle (`useEffect`, cleanup, unmount)
• Debugging with React DevTools + Profiler
• Preventing zombie subscriptions and stale state

***

### 3. System Design Session: Designing a Component Library for an Enterprise App (35 mins)

Objective: Architect a scalable and themeable component library with Storybook integration.
Discussion Points:

• Atomic design principles
• Style systems (Tailwind vs Styled Components)
• Component composition and accessibility

Key Concepts:

• `React.forwardRef`, `useImperativeHandle`
• Design tokens and theme context
• Publishing as NPM package

***

### 4. Real-World Product Issue: Handling Global Error Boundaries & Logging (25 mins)

Scenario: In production, certain user flows result in blank screens with no feedback.
Tasks:

• Implement a global error boundary that logs to an external service
• Display fallback UIs with user-friendly messaging

Key Concepts:

• `componentDidCatch` vs `useErrorBoundary`
• Integration with Sentry, LogRocket, or custom loggers
• Ensuring observability in SPAs

***

### 5. Q&A and React Roundtable (30 mins)

Open forum:

• Discuss real-world challenges like hydration errors, performance bottlenecks, or state explosion
• Interview insights for React engineers (2–6 YOE)
• Live review of participant projects or portfolio advice

***

> ✅ Bonus Add-on for Recruiter/Team Use:
> Series 2 – "ReactJS Pro Advanced":

• React + GraphQL integration
• State machine with XState
• Lazy loading, code splitting, SSR & hydration
• Testing React apps with Cypress + Jest

Join Zoom Meeting

### Most Common DSA Patterns (as asked in FAANG interviews)

| Time | Session |
| ---- | ------- |
| 6:30 PM | Welcome + Icebreaker + What to Expect Tonight

– Introduction to FAANG mindset

– Audience poll (Kahoot/Slido)

– Surprise gifts & shoutouts |
| 6:45 PM | DSA Preparation Myths Busted

– How Google and Netflix REALLY interview

– Patterns > Problems: Why brute-force learners fail |
| 7:00 PM | Top 12 DSA Patterns Overview (Live Explainer) |
| 7:15 PM | Pattern 1: Sliding Window Deep Dive (Live Code) |
| 7:30 PM | Pattern 2: Two Pointers (With Visual Visuals) |
| 7:45 PM | Pattern 3: DP Made Simple – From Problem to Code |
| 8:00 PM | Live Google-style Mock Interview (1-on-1 + Feedback) |
| 8:30 PM | Resume & LinkedIn Tips to Crack FAANG |
| 8:50 PM | How to Practice + 90-Day FAANG Pattern Planner |
| 9:00 PM | Q&A + Group Access + Resource Drop (PDF + GitHub) |

These companies repeat patterns, not problems.
Here are the 12 golden patterns most frequently asked (Google, Amazon, Netflix, Microsoft):

| # | Pattern Name | Topics Covered | Sample Questions (FAANG-style) |
| --- | ------------ | -------------- | ------------------------------ |
| 1 | Sliding Window | Arrays, Strings | Max sum subarray, Longest substring without repeating chars |
| 2 | Two Pointers | Arrays, LinkedLists, Strings | Container With Most Water, Palindrome check |
| 3 | Fast and Slow Pointers | Linked Lists | Cycle Detection, Middle of Linked List |
| 4 | Merge Intervals | Arrays of intervals | Merge Intervals, Insert Interval |
| 5 | Cyclic Sort | Arrays, Sorting | Missing Number, Find Duplicate |
| 6 | Top K Elements | Heap, QuickSelect | K Closest Points, Kth Largest Element |
|

7 | Backtracking | DFS, Recursion | N-Queens, Word Search, Sudoku Solver |
| 8 | Binary Search | Arrays, Infinite Search Space | Search Rotated Array, Peak Element |
| 9 | Breadth-First Search (BFS) | Trees, Graphs | Level Order Traversal, Shortest Path |
| 10 | Depth-First Search (DFS) | Graphs, Trees | Connected Components, Island Count |
| 11 | Dynamic Programming | Recursion + Memo | Knapsack, Longest Subsequence, Edit Distance |
| 12 | Greedy | Sorting + Decision | Activity Selection, Huffman Coding

|

📍 Live on YouTube + Zoom + In-person (Bangalore/Hyderabad)
👥 Expected Audience: 500+
Join Zoom Meeting

Inside Kafka: The Distributed Log System That Powers the World’s Data Pipelines

Dive deep into how Kafka delivers high throughput, fault tolerance, and exactly-once semantics by coordinating brokers, partitions, replicas, producers, and consumers in a highly distributed system.

***

## 🔍 Target Audience:

• Backend Engineers (2–8 years experience)
• DevOps & Platform Engineers
• Architects designing event-driven systems
• Data Engineers working with real-time pipelines

***

## 🗓️ Duration:

3 Hours
(60 mins presentation + 30 mins Q&A / 60 min live debugging / group activity)

***

| Time | Segment Title | Key Takeaways |
| ---- | ------------- | ------------- |
| `00:00 – 00:15` | 🚀 Why Kafka is Not Just a Queue | Real-world architectures (LinkedIn, Netflix, Uber). Why Kafka > RabbitMQ/Kinesis, use case fit |
| `00:15 – 00:35` | 🧱 Kafka Core Architecture Deep Dive | Brokers, Partitions, Leaders, ISR, Topics, Replication Factor, durability through logs |
| `00:35 – 01:00` | 🔄 Producer Internals & Optimizations | Idempotent producers, acks (0, 1, all), retries, batching, partitioning logic, compression |
| `01:00 – 01:20` | 🔁 Consumer Internals & Group Mechanics | Offset tracking, rebalancing, consumer groups, commit strategies, consumer lag |
| `01:20 – 01:40` | 🔐 Exactly-Once Semantics & Transactions | How EOS works: transactional producer + offset commit in same tx; fencing, idempotency |
| `01:40 – 02:00` | 🧠 Broker Metadata, Controller, Zookeeper/KRaft | Role of the controller node, leadership election, metadata sync, Zookeeper vs. KRaft (Raft Protocol) |
| `02:00 – 02:15` | ☕ Break + Networking | Informal discussion and mini-poll on Kafka usage in attendee projects |
| `02:15 – 02:35` | 🔍 Kafka Failure Modes & Debugging Lessons | Leader re-election, partition under-replication, consumer lag, ISR shrink, backpressure handling |
| `02:35 – 02:55` | 📏 Tuning Kafka at Scale (Throughput vs Durability) | Message size, batch settings, disk throughput, segment size, flush settings |
| `02:55 – 03:10` | 🛠️ Live Demo: Producer Crash with Exactly-Once | Simulate crash + restart of producer with transactions enabled; verify no duplicate consumption |
| `03:10 – 03:30` | 💬 Q&A / System Design Scenarios + Quiz | “What would happen if…” network partition, controller fails, Kafka Streams for microservice state |

## 🧪 Live Demo :

“Exactly-Once Delivery in Action”

• Producer sends transactional messages
• Consumer processes with offset commit in same transaction
• Simulate crash & recovery
• Show how Kafka ensures no duplicate processing

***

## 📦 What Participants Will Walk Away With:

• Mastery over Kafka’s internals and distributed log behavior
• Understanding of reliability vs performance trade-offs
• Practical knowledge of designing and debugging Kafka pipelines
• GitHub repo with example code and troubleshooting tips

Join Zoom Meeting

Why it works: Most pros know K8s basics—this dives into real-world challenges and solutions.

Subtopics:

• Real production outage war stories
• Node pressure, evictions, autoscaling pains
• Resource tuning (CPU/Mem/Pod limits)
• Monitoring beyond Prometheus & Grafana
• Readiness/Liveness vs startup probes
• Helm pitfalls and GitOps wins

💡 Add Live Demo: Chaos engineering with `kubectl` and `chaos-mesh`.
***

### ⚙️ 2. “Kubernetes at Scale: 1 Million Pods and 10,000 Nodes”
Why it works: Shows high-scale architecture and tuning—perfect for infra-heavy audiences.
Subtopics:

• etcd scaling and shard patterns
• kubelet optimizations, CRI tuning
• Cluster federation vs multi-cluster service mesh
• Use of CRDs to customize control plane
• Scaling logs/metrics/ingress

💡 Add Open-source Showcase: Show your infra-as-code Terraform/GitOps setup.
***

### 🔐 3. “Zero Trust Security in Kubernetes”
Why it works: Security is top priority; show real isolation models and best practices.
Subtopics:

• NetworkPolicies and Calico setup
• RBAC hardening (least privilege)
• Secrets management: HashiCorp Vault + K8s
• Zero trust service mesh (Istio/ZTunnel/Linkerd)
• Container image scanning (Trivy/Snyk)

💡 Live Attack Demo: Try a misconfigured pod → access cloud metadata, then fix.
***

### 🚀 4. “From Dev to Prod: Enterprise CI/CD with Kubernetes”
Why it works: DevOps folks love end-to-end automation.
Subtopics:

• Jenkins + ArgoCD + Helm flow
• Canary & Blue/Green deployments with Istio
• GitHub Actions + K8s deployment pipeline
• Secrets management in CI
• ChatOps and Slack deploy bots

💡 Live Deploy: Trigger code → GitHub Actions → ArgoCD deploy → verify in real-time.
***

### 🤖 5. “Kubernetes Operators: Automate Anything”
Why it works: Few people master Operators; it’s a hot area.
Subtopics:

• What’s an Operator vs Controller
• How to write one (Kubebuilder)
• Use case: Auto-scaling DB clusters, Backup jobs
• Watchers, Reconcilers, CRDs explained
• Real operator (e.g. Prometheus, Kafka)