Amrut Patil

Less focus on understanding transformers, more focus on serving them.

• Model architecture knowledge: nice to have
• Production deployment skills: essential
• Scaling inference: where the money is

Companies pay for reliability, not research papers.

Another framework for burnout prevention: the 48-Hour Reset Protocol.

- Assign a buddy engineer immediately.
- Block all non-critical meetings
- Create a rapid-fire question channel
- Deploy pre-built environments

Emergency intervention when warning signs are triggered.

The best distributed teams are just redundant expertise systems.

- 2+ engineers per critical system
- Cross-timezone knowledge coverage
- Eliminate single points of failure
- Prevent "only person who knows X" trap

When someone's irreplaceable, they're already burning out.

One of the biggest mistakes I see is assigning boring work to burned-out engineers.

- Give them complex, interesting problems.
- Increase cognitive load strategically
- Provide deep focus challenges
- Eliminate fragmented busywork

Satisfaction prevents burnout, not reduced workload.

Quick hack to eliminate database connection pooling issues while using Lambdas:

• Use RDS Proxy for connection multiplexing

• Implement connection pooling libraries

• Limit concurrent database connections

• Reuse connections across invocations

Cut cold start impact by 60-80% instantly.

Quick hack to prevent remote engineering burnout: implement conversation caps.

- Maximum 8 active Slack threads per person
- Reduces cognitive switching costs by 340%
- Protects deep work capacity
- Prevents async overload trap

Async chaos kills focus faster than any deadline.

Most people lift-and-shift during lambda to container migration, but optimize instead.

✔️ Use Alpine Linux base images
✔️ Implement multi-stage builds
✔️ Add async processing patterns
✔️ Configure connection pooling

Containerization strategy beats direct migration.

Most people track deployment metrics, but the trick is watching the silent struggle indicators.

60% commits after 8 PM

Away status during standups

Shorter PR descriptions

This pattern precedes 90% of cases of distributed team burnout.

The hybrid pattern: split VPC and public Lambdas.

• Public Lambda for API gateway logic
• VPC Lambda only for database calls
• Use SQS/EventBridge to decouple
• Reduces VPC cold starts by 70%

Keep security, eliminate most of the pain.

Lack of engagement

How to debug VPC cold starts so timeouts disappear.

• Check ENI limits in VPC console
• Monitor subnet IP exhaustion
• Review Lambda concurrency metrics
• Validate security group rules

Your 2 AM debugging sessions just got shorter.

Another mistake for Lambda VPC: scattered subnet architecture.

• Don’t use random subnets
• Group related functions together
• Use /24 or /23 CIDR blocks minimum
• Higher IP counts prevent ENI delays

I’ve seen /28 subnets cause 40+ second delays.

Another mistake for remote team management: ignoring async response time.

Track Slack/Teams reply delays.
Set a 4-hour SLA maximum
Alert when exceeded consistently

When communication lag hits >4 hours, you're 6 weeks from losing engineers.

4 steps for Lambda to container migration.

1. Audit current function performance
2. Optimize containerization strategy
3. Choose an orchestration platform
4. Execute a gradual traffic shift

Start with the highest-cost functions first.

5 monitoring metrics for VPC Lambda cold starts.

• InitDuration (VPC overhead)

• ENI allocation time

• Connection establishment time

• Subnet IP exhaustion

• Security group rule complexity

Stop tracking just duration, monitor what actually breaks.

Most people focus on endpoint hours, but the trick is monitoring data processing.

• $0.01/GB processing fees scale with usage
• High-traffic APIs generate $500+ monthly in processing
• API gateways and databases are the biggest cost drivers
• Set up granular CloudWatch alerts for spend spikes

Quick hack to cut Private Link costs: regional arbitrage.

• US-East-1 charges $0.01/hour for endpoints
• EU-West-1 charges $0.0125/hour (25% more)
• AP-Southeast-1 charges $0.015/hour (50% more)
• Choose regions strategically for latency-tolerant workloads

Quick tips for ECS Fargate vs EKS decision framework:

✔️ Fargate for HTTP APIs
✔️ EKS for complex networking
✔️ Auto-scaling requirements
✔️ Existing Kubernetes expertise

Choose based on actual needs, not hype.

10. Another framework for infrastructure decisions: the operational capacity reality check.

• No platform team = managed services
• Part-time infrastructure = hybrid
• Full-time platform engineers = custom
• Compliance needs = AWS-managed

Your team determines your architecture.​​​​​​​​​​​​​​​​

Key metrics to track Lambda to container post-migration.

✔️ Container startup vs cold start
✔️ Memory utilization efficiency
✔️ Request latency percentiles
✔️ Cost per request analysis

Use CloudWatch Container Insights for visibility.

One of the biggest mistakes I see is over-provisioning Lambda memory without measuring.

• Memory allocation controls CPU power linearly
• 512MB to 1024MB often halves execution time
• Higher memory costs less despite higher rates
• CloudWatch shows actual memory consumption

Don't migrate these Lambda functions to containers ever:

✔️ Infrequent traffic patterns
✔️ Simple single-purpose functions
✔️ Event-driven S3 triggers
✔️ DynamoDB event processing

Serverless still wins for true events.

One of the biggest mistakes I see is ignoring migration costs.

• Auto Mode to Karpenter = rebuild
• Karpenter to Auto Mode = feature loss
• 2-3 months migration time
• Potential downtime risks

Choose once, choose right.

Another reason Auto Mode fails: teams ignore workload isolation requirements.

• No custom node pools allowed
• Limited taint/label control
• Multi-tenant challenges
• Workload interference risks

Complex environments need Karpenter’s flexibility.

How to choose Lambda runtime so that cold starts don’t kill performance

• Go: 50-150ms cold starts, best for CPU tasks
• Node.js: 100-300ms, great ecosystem support
• Python: 200-500ms, good for data processing
• Java: 1-3 sec, expensive but powerful

Runtime choice can cut costs 70% for frequency.

Critical optimizations that eliminate serverless tax.

✔️ Health check endpoints are configured
✔️ Graceful shutdown handlers added
✔️ Resource limits are tuned properly
✔️ Horizontal Pod Autoscaler enabled

These changes pay for themselves immediately.

Quick hack to cut Lambda costs: audit first.

✔️ Check execution frequency patterns
✔️ Monitor memory utilization spikes
✔️ Track cold start error rates
✔️ Identify bloated dependencies

Functions running every 5 minutes need containers.

5 ways to cut Lambda costs without touching business logic:

• Memory allocation controls CPU power directly

• Move initialization to global scope completely

• Package size adds 100ms per extra MB

• Connection pooling saves 200-400ms per call

• Runtime choice impacts cold start speed

AI will generate the code.

It is your job to understand and explain the why behind the code it generated.

You need to understand why the code works, not just that it works.

More important if you are operating in senior or higher roles.

That cannot be replaced.