skills.rest
hung-phan
hung-phanCOMMUNITY
Explore all skills by this author →
GitHub

grpc

Identifies RPC design and debugging issues in gRPC/Protobuf services using HTTP/2.

Updated Jun 5, 2026
Search Tags:#gRPC#RPC#low latency#service design#service debugging
One-click install
npx skills add https://github.com/hung-phan/system-skills --skill grpc-hung-phan
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: grpc
Source: https://github.com/hung-phan/system-skills/tree/main/skills/system-review/references/communication/grpc
Command: npx skills add https://github.com/hung-phan/system-skills --skill grpc-hung-phan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps to address issues related to designing service-to-service RPCs, especially where typed contracts, streaming, and low overhead are needed. It is also useful for debugging common issues like latency spikes, traffic issues, and client-server mismatches.

Core Features & Use Cases

  • RPC Optimization: For designing and debugging service-to-service RPCs with typed contracts and low overhead.
  • Common Issues Debugging: Identify and resolve issues like "p99 latency spike after deploy," "all traffic pinned to one pod," and other common problems.
  • Use Case: For instance, it can be used to design service-to-service RPCs within a cluster or VPC, or to debug and resolve "gRPC works locally but fails behind ALB" issues.

Quick Start

To analyze a service design and identify patterns and common pitfalls, use the grpc skill to perform a review of the service architecture.

Frequently Asked Questions about grpc

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I debug gRPC p99 latency spikes and traffic mismatches in distributed systems?▼

To debug gRPC latency spikes and traffic mismatches, you must analyze service-to-service RPC design focusing on typed contracts and HTTP/2 behavior. Identifying patterns like connection pooling issues helps resolve common distributed system performance problems.

Why does gRPC work locally but fail behind an Application Load Balancer?▼

gRPC failing behind an ALB typically occurs due to HTTP/2 traffic mismatches and improper load balancing configuration. Analyzing the service architecture and RPC design helps identify and resolve these client-server connectivity issues in clustered environments.

How do I design service-to-service RPCs with typed contracts and low latency?▼

Designing low-latency service-to-service RPCs requires defining typed contracts using Protobuf and managing streaming over HTTP/2. Reviewing the service architecture identifies common pitfalls and ensures optimal inter-service communication within a VPC.

What causes all traffic to be pinned to one pod when using gRPC?▼

Traffic pinning to one pod during gRPC communication is caused by HTTP/2 connection multiplexing bypassing standard load balancing. Debugging the RPC design identifies these traffic mismatches and helps restore proper distribution across pods.

Related Skills

Explore More Software Engineering Skills→
ryan-nguyen-01ryan-nguyen-01
4

skill-api-grpc

Design gRPC services with protobuf schemas and streaming patterns.

Community
Advanced
pluginagentmarketplacepluginagentmarketplace
1

service-mesh

Configure and operate Istio and Linkerd service meshes on Kubernetes.

Community
Advanced
JingyueCongJingyueCong

wireshark-analysis

Analyze PCAP files to identify communication issues and security anomalies.

Community
Advanced
mindcockpit-aimindcockpit-ai
11

go-messaging

Enable inter-service messaging in Go with channels, goroutine pools, and external brokers.

Official
Advanced