Brush your teeth like your dentist is watching.
Take a shower each morning like you're washing off the negativity of yesterday.
Get dressed like your crush is waiting outside.
Work like your kids are going to need it some day.
Work out like your trainer is in the room.
Read like the next chapter has the answer.
Lead like your circles will write a book about you.
Speak like every word you say is going to be held against you in the future.
Take the stairs like the elevator is broken.
Spend time with your loves one like it's the last day you'll have with them.
Recently I interviewed a Senior Engineer.
Strong candidate.
Kafka? ✅
Redis? ✅
Microservices? ✅
Distributed systems? ✅
Then I asked:
"Your payment service processes a $49 charge for an order."
A customer clicks Pay.
The request reaches your payment service.
The card is charged successfully.
But before your service can mark the order as paid and send the response, the network connection drops.
The customer sees:
"Payment failed."
They click Pay again.
Meanwhile, the first charge already went through.
Now the customer has been charged twice for the same order.
How do you guarantee the customer is charged exactly once — even with retries, timeouts, and network failures?
"Just use a database transaction."
Doesn’t fully solve the distributed failure + retry case across services.
"Store the payment status in Redis."
What happens if Redis is unavailable when the second request arrives?
"Check if the order is already paid before charging."
What happens when two requests check the status at exactly the same time?
Your turn:
How would you design this payment API so concurrent requests and retries never double-charge the customer?
There’s a specific distributed-systems concept behind this.
And you’ll encounter it everywhere payments, orders, and financial systems are involved.👇
Kubernetes is beautiful.
Every Concept Has a Story, you just don't know it yet.
In k8s, you run your app as a pod. It runs your container. Then it crashes, and nobody restarts it. It is just gone.
So you use a Deployment. One pod dies and another comes back. You want 3 running, it keeps 3 running.
Every pod gets a new IP when it restarts. Another service needs to talk to your app but the IPs keep changing. You cannot hardcode them at scale.
So you use a Service. One stable IP that always finds your pods using labels, not IPs. Pods die and come back. The Service does not care.
But now you have 10 services and 10 load balancers. Your cloud bill does not care that 6 of them handle almost no traffic.
So you use Ingress. One load balancer, all services behind it, smart routing. But Ingress is just rules and nobody executes them.
So you add an Ingress Controller. Nginx, Traefik, AWS Load Balancer Controller. Now the rules actually work.
Your app needs config so you hardcode it inside the container. Wrong database in staging. Wrong API key in production. You rebuild the image every time config changes.
So you use a ConfigMap. Config lives outside the container and gets injected at runtime. Same image runs in dev, staging and production with different configs.
But your database password is now sitting in a ConfigMap unencrypted. Anyone with basic kubectl access can read it. That is not a mistake. That is a security incident.
So you use a Secret. Sensitive data stored separately with its own access controls. Your image never sees it.
Some days 100 users, some days 10,000. You manually scale to 8 pods during the spike and watch them sit idle all night. You cannot babysit your cluster forever.
So you use HPA. CPU crosses 70 percent and pods are added automatically. Traffic drops and they scale back down. You are not woken up at 2am anymore.
But now your nodes are full and new pods sit in Pending state. HPA did its job. Your cluster had nowhere to put the pods.
So you use Karpenter. Pods stuck in Pending and a new node appears automatically. Load drops and the node is removed. You only pay for what you actually use.
One pod starts consuming 4GB of memory and nobody told Kubernetes it was not supposed to. It starves every other pod on that node and a cascade begins. One rogue pod with no limits takes down everything around it.
So you use Resource Requests and Limits. Requests tell Kubernetes the minimum your pod needs to be scheduled. Limits make sure no pod can steal from everything around it. Your cluster runs predictably.
Mbak makasi ya udah dikasi tau kalo
air kelapa + chia seed = combo besst buat ngempesin perut buncit. Ternyata real, serius ini bb udah lost 2kilo dalam seminggu 👏🏼
@Tech_glareOffl Location is correct but it’s not accurate.if AirPod is still there on road then we can find through the app otherwise it’s not possible
One thing you can do is mark that device as lost in app and update your contact details along with txt & see if you’re lucky or not
@biased_human This is great Man 🙌🏻 I’m too from Bihar and living here in Bangalore.. Thanks for sharing this.. Now I can hear Chhath song along with the countdown timer which will remind me the number of days left for this biggest festival of our Bihar/UP.