gRPC & Protocol Buffers

Understands gRPC fundamentals in Java: proto file definitions, code generation with protobuf-maven-plugin, and basic unary RPC calls. Follows team patterns for implementing gRPC services with Spring Boot gRPC starter.

Understands gRPC fundamentals in Node.js: proto file definitions, code generation with @grpc/proto-loader, and basic unary calls. Follows team patterns for implementing gRPC services with grpc-js and NestJS gRPC transport.

Understands gRPC concepts and their applicability in PHP: knows PHP limitations for streaming scenarios, can install grpc extension and call unary RPC. Understands why PHP projects use gRPC for communication with microservices in other languages.

Understands gRPC fundamentals in Python: proto file definitions, code generation with grpcio-tools, and basic unary calls. Follows team patterns for implementing gRPC services with grpcio and async support via grpclib.

Understands gRPC fundamentals in Rust: proto file definitions, code generation with tonic-build, and basic unary calls. Follows team patterns for implementing gRPC services with tonic framework and type-safe protobuf message handling.

Understands gRPC fundamentals in Scala: proto file definitions, code generation with ScalaPB, and basic unary calls. Follows team patterns for implementing gRPC services with Akka gRPC or ZIO gRPC functional streaming.

Develops gRPC services in Java/Kotlin: implements streaming RPC, configures ServerInterceptor for authentication and tracing, integrates with Spring Boot via grpc-spring-boot-starter. Uses async stub with ListenableFuture for non-blocking calls.

Develops gRPC services on Node.js: implements streaming RPC, integrates with NestJS via @grpc/grpc-js, configures metadata for auth tokens and trace context. Uses ts-proto or protobuf-ts for type-safe TypeScript code generation from .proto.

Integrates PHP applications with gRPC services: generates PHP clients from .proto via protoc, configures channel credentials for TLS, handles errors through Status codes. Uses Spiral/RoadRunner for implementing gRPC servers in PHP without FPM limitations.

Develops gRPC services in Python with grpcio/grpcio-tools: designs .proto files, implements server-side and client-side streaming, configures interceptors for logging and authentication. Integrates gRPC with asyncio for non-blocking request processing.

Develops gRPC services in Rust with tonic: implements streaming RPC with tokio-stream, configures Tower middleware for interceptors, uses tonic-health for health checking. Applies Rust type system for compile-time guarantees of correct gRPC interactions.

Develops gRPC services in Scala: uses Akka gRPC or ZIO gRPC for implementing services with streaming, integrates with Akka Streams for backpressure-aware processing. Configures ScalaPB transformations for customizing generated code.

Designs gRPC architecture for Java microservices: configures deadline propagation via Context, implements retry policies with exponential backoff, integrates with Micrometer for metrics and Brave/OpenTelemetry for tracing. Optimizes Netty transport for high loads.

Designs gRPC architecture for Node.js services: configures gRPC-Web via Envoy proxy for browser clients, implements middleware chains for observability, optimizes event loop for high-load streaming scenarios. Integrates gRPC with existing Express/Fastify API via dual-protocol servers.

Designs gRPC integration for PHP systems: determines which services to implement as gRPC servers (Spiral/RoadRunner) vs gRPC clients, configures retry logic and deadline propagation, integrates with OpenTelemetry for end-to-end tracing. Optimizes performance through persistent connections.

Designs gRPC API for microservice architecture: defines proto file versioning strategy, configures gRPC-gateway for REST compatibility, implements health-checking and graceful shutdown. Optimizes performance through connection pooling and keepalive parameters.

Designs high-performance gRPC services in Rust: optimizes through custom allocators and zero-copy deserialization, configures TLS through rustls, implements connection pooling with Tower balance. Benchmarks and profiles gRPC services for maximum throughput.

Designs gRPC architecture for Scala microservices: integrates with Akka Cluster for distributed gRPC services, implements service discovery through Akka Discovery, configures gRPC with Kamon/OpenTelemetry for observability. Optimizes production gRPC server configuration on Akka HTTP.

Standardizes gRPC development in the company's Java ecosystem: creates code-generation plugins for uniform services, implements proto-lint in CI/CD, designs patterns for gRPC integration with Kafka and Spring Cloud. Trains teams on gRPC API design best practices.

Standardizes gRPC development in Node.js ecosystem: creates service templates with built-in interceptors, defines proto-first development strategy with automatic TypeScript SDK generation for clients. Designs error handling and retry patterns for Node.js-specific constraints.

Leads gRPC adoption in the company's PHP ecosystem: defines gradual migration strategy from REST to gRPC for internal communications, standardizes PHP client generation in CI/CD, designs compatibility with existing API Gateway. Trains PHP developers on protobuf and gRPC.

Defines gRPC communication standards in the organization: selects proto contract management strategy (Buf, proto-lint), implements service mesh integration with Envoy/Istio for gRPC traffic, designs retry/deadline propagation patterns. Trains teams on proper gRPC API design.

Defines gRPC architecture for Rust ecosystem: creates procedural macros to simplify gRPC service implementation, designs integration with async runtime (tokio/async-std), standardizes error handling through thiserror and custom Status codes. Mentors team on idiomatic Rust for gRPC.

Standardizes gRPC development in Scala ecosystem: chooses between Akka gRPC, ZIO gRPC and fs2-grpc for different teams, creates sbt plugins for standardizing proto generation, designs patterns for functional error handling in gRPC. Defines testing strategy with akka-grpc-testkit.

Defines enterprise-level gRPC communication strategy: designs API Gateway integration (Kong, Envoy) for gRPC transcoding, develops platform for managing proto contracts with versioning and dependency tracking. Influences transport protocol choices in hybrid cloud architecture context.

Defines communication protocol strategy for Node.js platform: designs architecture for hybrid REST/gRPC/WebSocket API, develops internal platform for automating gRPC service lifecycle. Influences architectural decisions on scaling Node.js gRPC in cluster mode.

Shapes transport protocol strategy for hybrid PHP systems: defines gRPC vs REST vs GraphQL applicability boundaries in PHP context, designs architecture for gradual service extraction from PHP monolith with gRPC communication. Influences PHP gRPC ecosystem development.

Shapes inter-service communication strategy at platform level: defines when to use gRPC vs REST vs async messaging, designs infrastructure for proto-registry and multi-language client auto-generation. Influences architectural decisions on introducing gRPC to legacy systems with minimal disruption.

Shapes strategy for using Rust in critical gRPC services: defines when Rust is justified vs Go/C++ for gRPC, designs FFI integration for calling Rust gRPC services from other languages. Contributes to tonic/prost ecosystem and influences gRPC development in the Rust community.

Shapes gRPC strategy for functional Scala systems: designs architecture for polyglot gRPC communication between Scala and other JVM/non-JVM languages, defines approach to schema evolution for long-lived protocols. Contributes to Scala gRPC ecosystem development (ScalaPB, Akka gRPC).