Addy Osmani is an Irish Software Engineer and leader currently working as a director at Google Cloud AI, focused on helping developers and businesses succeed with Gemini, Vertex AI, and the Agent Development Kit (ADK). After nearly 14 years leading developer experiences in Chrome, he now bridges Google DeepMind, engineering, product, and developer relations teams. A developer for 25+ years at Google, he is passionate about AI-assisted engineering and developer tools. Follow for motivation, productivity and engineering.

Addy Osmani

Introducing our biggest Google Maps upgrade yet - powered by Gemini!

Today Google Maps is getting its biggest upgrade in over a decade!

By combining our Gemini models with a deep understanding of the world, Maps now unlocks entirely new possibilities for how you navigate and explore. 

Here's what you need to know:

🗣️ Ask Maps A new way to get answers to your complex, real-world questions with a simple conversation. Try asking things like:

"My phone is dying - where can I charge it without having to wait in a long line for coffee?" 🔋

"Is there a public tennis court with lights on that I can play at tonight?" 🎾

"I'm headed to the Grand Canyon, Horseshoe Bend, and Coral Dunes - any recommended stops along the way?" 🏜️

No more sifting through research and reviews - just tap "Ask Maps" and get your questions answered with a customized map. (Starts rolling out now in the U.S. and India on Android and iOS, with desktop coming soon).

🚗 Immersive Navigation (that first demo!)

The Maps driving experience is also evolving with clearer visuals and intuitive guidance. You’ll be able to see the buildings, overpasses, and terrain around you in a vivid 3D view, made possible with help from Gemini models.

You’ll also be able to:

1. See more of your route to prepare for what’s next.
2. Understand trade-offs for alternate routes to pick what works best for you.
3. Arrive easily with helpful details like parking and entrance information.

Really excited about these updates! Go Gemini!

#ai #programming #softwareengineering

Director, Google Cloud AI. Best-selling Author. Speaker. AI, DX, UX. I want to see you win.

You can instantly 10x your AI-generated frontends just by learning what different UI components are called.

The Component Gallery (https://component.gallery) is a comprehensive visual reference for standard UI patterns and their proper names ⚡ 

When delegating tasks to coding agents, the quality of your output is bottlenecked by the specificity of your input. If the only vocabulary you use in your prompts are generic words like "menu" or "button," the model will naturally return generic results.

To get high-fidelity interfaces, you need the right shared language for spec-driven development. Knowing when to ask for a "combobox" instead of a "dropdown" or a "segmented control" instead of a "toggle" gives the AI the exact context it needs to execute your vision. The Component Gallery walks through this really well.

UI Design Brain is also an open-source taxonomy for UI skills and component design. (https://lnkd.in/gYYbhv5q) based on the Component Gallery.

Mastering this terminology is a small investment that massively upgrades your prompt engineering.

#ai #programming #softwareengineering

"WebMCP - MCP Is Coming to the Browser"

The Model Context Protocol just got a proposal to bring it natively to the web.
WebMCP is a new JavaScript API that lets web apps expose their functionality as "tools" that AI agents can invoke directly in the browser. Think of web pages as MCP servers - but running entirely client-side, using your existing frontend code. Available as a Google Chrome Early Preview.

Why this matters:

→ Web developers can declare what their app does in a machine-readable way using APIs they already know 
→ Browser agents can discover and call these tools - no backend MCP server required 
→ Two approaches: 1) a declarative API for standard actions via HTML forms  and 2) an imperative API for complex dynamic interactions via JavaScript 
→ Users and agents share the same UI context, enabling cooperative workflows where you delegate the tedious parts and stay in control of the decisions

The use cases click immediately: an agent that can actually search flights, configure options, and handle bookings through structured data. Customer support tickets that get auto-filled with the right technical details. E-commerce flows where an agent navigates checkout with precision instead of fumbling through DOM elements.

Pietro Schirano built a great demo showing this in action - a DoorDash-style app where the agent adds items to cart and checks out with the right address and promo code, without ever needing to "see" the UI. That's the shift really - agents shouldn't have to screenshot or dump HTML to use your app. Just expose your tools.

This is also potentially huge for accessibility - assistive tech that can understand app capabilities semantically, offering users higher-level actions instead of navigating individual UI elements.

We went from "MCP for desktop tools" to "MCP for the entire web" in months. The pace of this protocol's adoption is remarkable.

If you're building web apps, this is worth watching closely.

🔗 WebMCP Proposal: https://lnkd.in/gxbhzPQ9 
🔗 Chrome Early Preview: https://lnkd.in/gySqDEKS
🔗 Syntax.fm deep dive: https://lnkd.in/gbDfWuFn
🔗 Pietro's WebMCP starter: https://lnkd.in/gMWCksvZ

#ai #programming #softwareengineering

An engineer at Anthropic wrote a spec, pointed Claude at an Asana board, and went home. Claude did the rest.

Claude broke the spec into tickets, spawned agents for each one, and they started building independently. When an agent got confused, it ran git-blame and messaged the right engineer in Slack.

By Monday, the agents had finished the feature.

This is the part that fascinates me most: the agent's learning loop mirrors how a new team members onboards. It reads the codebase, identifies who knows what, and asks the right humans. Slack and email - that's all it needed.

We're approaching a world where developers orchestrate dozens of AI agents in parallel. And when that happens, the differentiator between a good engineer and a great one comes down to one thing:

The quality of your specs.

You can't write a spec that holds up at that scale without genuinely understanding what you're building at a deeper level. Architecture, edge cases, failure modes, integration points. The spec IS the product thinking.

Having agents run over the weekend to ship work will start to become entirely normal. There's zero reason you wouldn't add two extra days of output with a couple of prompts and a machine running in the background.

That said - I'm always a little skeptical of how viable these patterns broadly are but do think this is the direction we're heading in. Verification remains the biggest unsolved challenge. Tests that pass on the pre-patch codebase, UI verification, pathological coding practices leaking into the context window. We need slightly better models and much better evaluation infrastructure for this to become the default. I believe we will get there.

But the trajectory is clear: the next-gen developer who understands fundamentals, can architect well, and knows how to orchestrate agents is going to be a force-multiplier.

#ai #programming #softwareengineering

Anthropic has launched free courses to master AI with certificates for $0! 

You can find the full catalog here: https://lnkd.in/gxXNxesb

Yes, they're worth it - especially if you're a web developer. These free Anthropic Academy courses are short (mostly 1-2 hours each), entirely self-paced with videos and quizzes, and provide official certificates of completion when you're done. There's even Claude on Vertex guidance on there.

For developers, the technical tracks are highly practical. They teach you how to move past basic prompting and start building real AI integrations into your daily workflow:

🔹 Claude Code in Action: Learn how to integrate Claude Code directly into your development workflow, master CLI tools, and handle complex context management.
🔹 Building with the Claude API: A comprehensive, hands-on look at working programmatically with Anthropic models.
🔹 Introduction to Model Context Protocol (MCP): Master MCP’s core primitives (tools, resources, and prompts) to connect Claude with external services using Python.
🔹 Claude 101 & AI Fluency: Strong foundations for collaborating with AI systems efficiently and safely.

Understanding context management, agent skills, and API workflows is quickly becoming a critical engineering baseline. These courses give you a phenomenal foundation for AI-assisted development. Plus, the certificates come directly from a top-tier lab, offering a solid signal of real, applied skills to add to your LinkedIn profile or resume.

Enroll and knock out a couple today. 

For those building in the Google ecosystem, make sure to check out the "Claude with Google Cloud's Vertex AI" It's an excellent, comprehensive guide to working with Anthropic models at enterprise scale!

#ai #programming #softwareengineering

Chrome just became massively more agent-friendly 🔥 Your real, signed-in browser can now be natively accessible to any coding agent (with a toggle)

One toggle in chrome://inspect/#remote-debugging and your real, signed-in browser is now natively accessible to any coding agent. Just use this with Chrome DevTools MCP auto connect. OpenClaw just added support too.

No extensions.
No headless browser.
No screenshots.
No separate logins.

Check this out: https://lnkd.in/gNcDHFnV

Your agent finally sees your web the exact tabs, cookies, dashboards, Linear boards, Notion pages, and internal tools you already have open.

This is the moment the biggest friction in browser agents disappeared. 

Google shipped native DevTools MCP live-session attach (Chrome 146+), and tools like OpenClaw and Browser Use instantly plugged in.

https://lnkd.in/gwnKE6fd

Tested it instantly: told my OpenClaw to check my live Google Analytics traffic dashboard. It opened the tab I already had logged in, read the real numbers, and dropped them straight into a weekly report. Zero extra steps. Note: I give my agents their own accounts (e.g. Google account, specific permissions on their accounts for other sites) as this gives me better security isolation.

The same toggle works for Claude Code, gemini-cli, and any MCP-native agent. 

This closes the "my agent can browse the web… but not my web" gap.

#ai #programming #softwareengineering

Introducing the Google Workspace CLI: https://lnkd.in/gpRfeFvR - built for humans and agents.

Google Drive, Gmail, Calendar, Sheets, Chat and every Workspace API. 

The repo ships many Agent Skills - one for every supported API, plus higher-level helpers for common workflows and 50 curated recipes for Gmail, Drive, Docs, Calendar, and Sheets. 

Great work here by Justin Poehnelt 🙏  

#ai #programming #softwareengineering

Boris created Claude Code. His point here is important -  when AI handles the code generation, the engineer's value shifts to the decisions above the code: 

1. what do we build?
2. why? for whom? 
3. and how it all fits together. 

The bottleneck was always judgment, taste, and systems thinking. AI just made that more obvious. I continue to believe that as engineering and product roles evolve (and even converge) through this time, taste is so important.

For me, the line is roughly:

Agents handle
• code co-authoring
• low-risk code reviews
• tactical planning inside a clearly defined feature

I stay very involved in
• technical / UX design
• feature briefs, high-risk reviews
• app-level intent and constraints

The leverage feels highest when humans stay crisp on "what problem, what constraints, what good looks like" and let agents explore the solution space aggressively underneath that.

#ai #programming #softwareengineering

"I was a 10x engineer. Now I'm useless." here's my take:

AI will encourage software engineers to be more deliberate about what thinking we protect, what code we read and what bottlenecks only we can still unblock.

This may be work with high-dimensional search spaces, where the bottleneck isn't code at all but judgment, taste, domain knowledge, or where hard questions that have to be answered before the code even matters. 

On code, I don't think the choice is between reading all the code and reading none of it. I still read lots of code - just not all of it. The question is developing judgment about which parts actually need your eyes on them. Even if I have multiple agents working together to write code, I always account for some review time and some quality inspection.

A lot of developers have spent years building a professional identity around their ability to figure things out. Mo's video is about what happens when you quietly let something else do the figuring out, and then look up one day and realize the skill isn't there anymore.

Video credit is Mo Bitar (https://lnkd.in/gPdByU9x) who I've enjoyed listening to lately and is worth a follow.

#ai #programming #softwareengineering

Tip: Stop using /init for AGENTS.md to get better performance

My latest deep-dive: https://lnkd.in/gkmZ3HJs ✍ 

As we transition deeper into AI-assisted engineering and background agent orchestration, there's a common ritual: setting up a new project, running an auto-generation tool, and committing a comprehensive AGENTS.md context file. It feels like the responsible thing to do.

But recent 2026 research from ETH Zurich and others reveals a different reality: auto-generated context files can actually reduce task success by 2-3% while inflating costs by over 20%.

Why? Because coding agents can already discover your directory structure, tech stack, and module explanations on their own. Handing them an auto-generated summary just adds noise, burns tokens, and dilutes their attention from the actual task.

So, what actually earns a line in your AGENTS.md?

1. The undiscoverable: Tooling gotchas that change operations
2. Operational landmines: "The legacy/ directory is deprecated but imported by production - do not delete."
3. Non-obvious conventions: Custom middleware patterns that shouldn't be refactored to standard conventions.

If an agent can discover it by reading your code, delete it from the file.

A better mental model: Treat your AGENTS.md as a living list of codebase smells you haven't fixed yet. If an agent keeps reaching for the wrong dependency or putting utilities in the wrong folder, don't just add a prose instruction to the context file. Restructure the code, add a linter rule, or improve the test coverage. Treat it as a diagnostic tool, fix the underlying friction, and then delete the line.

I dive into the data, the "pink elephant" problem of context anchoring, and why monolithic context files need to evolve into dynamic routing layers in my latest post. 

How is your team currently managing context for your background coding agents? Are you relying on static files, or exploring more dynamic context loading? Let me know in the comments.

#ai #programming #softwareengineering

Announcing Gemini 3.1 Pro! Google's smarter model for your most complex tasks just shipped!

Last week, we released a major update to Gemini 3 Deep Think to solve modern challenges across science, research, and engineering. Today, we are releasing the upgraded core intelligence that makes those breakthroughs possible: Gemini 3.1 Pro.

Gemini 3.1 Pro is now available for developers, users and enterprise. I'm sharing some fresh demos showing off just a little of what it can do :)

Building on the Gemini 3 series, 3.1 Pro represents a massive step forward in core reasoning. It is designed for tasks where a simple answer is not enough. The model delivers a 77.1% score on the ARC-AGI-2 benchmark, which effectively doubles the reasoning performance of Gemini 3 Pro.

This is a noticeably smarter, more capable baseline for complex problem-solving. Gemini 3.1 Pro excels at workflows where the model must decide for itself how to build the right solution. 

Whether it is modeling complex systems, orchestrating multi-step logic streams, or acting as a more powerful foundation for creative coding, this model makes tough tasks feel simpler.

We are shipping 3.1 Pro at scale starting today:

For developers: Available in preview via the Gemini API in Google AI Studio, Gemini CLI, Android Studio, and our agentic development platform, Google Antigravity. Note that these are in progress of rolling out.

For consumers: Available via the Gemini app and on NotebookLM for Pro and Ultra subscribers.

For enterprises: Available in Vertex AI and Gemini Enterprise.

While we have made a lot of progress, we are already looking ahead to further improving how our models work in broader, more ambitious agentic workflows. We will continue to refine performance around accurate tool selection, complex instruction following, and extended coding tasks.

Whether you are a developer, a student, or just brainstorming a big idea, we can't wait to see what you build and discover with this new level of intelligence.

#ai #programming #lifeatgoogle

We used Gemini 3.1 Pro to build a realistic city planner app, and the multimodal reasoning on display is incredible!

Some great work from Google DeepMind, Michael Chang and team using our new 3.1 Pro release. I wanted to share a little more about how this works.

You can watch how the model tackles complex terrain, maps out infrastructure, and simulates traffic to generate a high-quality visualization. It's a fantastic look at how we can use AI to reason through large-scale, real-world spatial constraints.

Here is a breakdown of what the model is handling under the hood:

🗺️ Terrain analysis: Gemini writes individual programs to generate topography and discover shorelines. It analyzes the flat areas and water placement to build a foundational map in the app's dashboard. 

🌉 Infrastructure mapping: The model seeds the map with urban hubs based on resource locations, layering in basic wireframes before algorithmic generation takes over. 

🚗 Traffic simulation: To build the roads, the app simulates thousands of trips between these hubs. By analyzing how people would theoretically travel, it generates the optimal road networks around the natural terrain. 

✨ High-quality visualization: The finale generates a polished, photorealistic satellite view of this fictional city. From there, clicking anywhere on the map prompts Gemini to imagine and generate detailed "aerial photography" perspectives of specific neighborhoods.

As noted in the demo, Gemini 3.1 Pro has taken a massive leap forward in caring about user intent - seamlessly combining text prompts, spatial math, and image synthesis. We'll also see if we can open-source some of the prompts involved :)

Gemini 3.1 Pro is now available and rolling out to your favorite developer tools.

#ai #programming #softwareengineering

Announcing the new Google Gemini powered Docs, Sheets, Slides, and Drive! More context, fulled editable AI slides, and new grounding sources!

Available today to G1 Pro and Ultra users!

🚀 Google is fundamentally reimagining how we work across Google Docs, Sheets, Slides, and Drive. 

I'm incredibly excited to see Google Workspace become more contextual, helpful, and collaborative. We've all stared down a blinking cursor or an empty spreadsheet - getting started is often the hardest part. Now, you can simply choose your sources, and Gemini will securely connect the dots and uncover useful insights for you.

Here is a look at the new way of working:

📝 Docs is your new writing partner
Get a customized first draft instantly by asking Gemini to draw from your existing files. You can effortlessly refine sections, strengthen your message, and seamlessly match your unique voice or a specific document format.

📊 Sheets build complex sheets 9x faster

Describe what you need, and Gemini will set up the entire spreadsheet, pulling details directly from your inbox and files. You can even populate missing data instantly by accessing real-time web results - saving hours of manual research. (Plus, Gemini in Sheets is now #1 on the SheetsBench leaderboard!)

🎨 Slides let you go from concept to Presentation-Ready faster

Go from a rough concept to a polished deck with a simple prompt. Gemini acts as your design collaborator to generate beautiful, fully editable slides that align with your theme and pull context from your existing work. (Generating entire decks from a single prompt is coming soon!)

📂 Drive is your active collaborator

When you search in everyday language, Drive now generates a summarized AI Overview right at the top of your results. You can also use "Ask Gemini" to have a multi-turn conversation with your files and folders - all without opening a single document.

These features are rolling out today in beta for Google Workspace Gemini Alpha customers, as well as Google One AI Ultra and AI Pro subscribers.

#googleworkspace #programming #ai

Full Stack developer | content creator| open for collabs| freelancer

🚀 Relentlessly Growing 1% Every Day

I’m a Senior Backend Developer currently working at 42Gears, where I focus on
building scalable, reliable, and high-performance backend systems used at
enterprise scale.

Previously, I’ve worked in a startup environment at AstrotimeApp, which
strengthened my ability to move fast, take ownership, and deliver
production-ready solutions end-to-end.

My journey in tech is driven by continuous learning and real-world problem
solving. I believe in improving a little every day—whether it’s mastering a
new framework, refining system design, or optimizing performance in
distributed systems.

💻 Core Technical Expertise

Backend & Systems  
• Java, Spring Boot  
• Node.js, Express.js  
• .NET  
• Golang, Python  

Databases & Messaging  
• MongoDB, Microsoft SQL Server  
• Redis  
• Apache Kafka  
• MQTT  

Frontend (Working Knowledge)  
• AngularJS, Angular  
• TypeScript  

Cloud & DevOps  
• AWS  
• Docker  
• Microservices Architecture  
• Nginx  

🌱 What I’m Focused On Right Now  
• Designing and scaling microservices  
• Improving system reliability, performance, and observability  
• Deepening expertise in cloud-native architectures  
• Writing clean, maintainable, production-grade backend code  

🤝 Open to sharing learnings, career guidance, and real-world backend
experience with developers and students.

👉 Book a 1:1 career guidance session here:  
https://topmate.io/kartik_kaushik11

Kartik Kaushik

Hi Linkedin Community I hope you Guys are doing well

A Great List of Tech Articles to Read This Weekend:

1)Titans: Google’s New Architecture : https://lnkd.in/gUVSzmxi By Ludovico Bessi


2)𝗛𝗼𝘄 𝗜 𝗳𝗮𝗶𝗹𝗲𝗱 𝗺𝘆 𝗳𝗶𝗿𝘀𝘁 𝗖++ 𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 by Nikolai Kutiavin
https://lnkd.in/gPkcctSM

3)𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵 - 𝗥𝗲𝗰𝘂𝗿𝘀𝗶𝘃𝗲 𝗩𝗦. 𝗜𝘁𝗲𝗿𝗮𝘁𝗶𝘃𝗲 By NeetCode https://lnkd.in/gy7VTCcY

4)How to Prevent the DB from Becoming a Bottleneck By Saurabh Dashora
https://lnkd.in/gm4xAbAQ

5)If you’re using Athena to query tiny datasets By API by Yan Cui
https://lnkd.in/gGdKEfYC

6)Want to make your .NET apps more resilient?
by Milan Jovanović : https://lnkd.in/gpqnSAgS

7) Ebook Reader Challenge by John Crickett:https://lnkd.in/g8vbuGnh

8)There is a very interesting hashing approach called Robin Hood Hashing. By Arpit Bhayani
https://lnkd.in/gEaVSyck

9)𝗧𝗜𝗟: Instead of fighting with weird bastion hosts or other workarounds by Tobias Schmidt 
https://lnkd.in/guEZcBk9

10)AWS just unified serverless payload limits at 1 MB By 
Ivo Pinto :https://lnkd.in/g73t7_EC

11)7 ways to avoid Postgres lock hell:
 👇:. By Alexandre Zajac
https://lnkd.in/gZ46W8aH

12)NGINX Architecture By Hussein Nasser :https://lnkd.in/ghYEy-9Q

13)The SDLC isn’t a checklist.: by Nikki Siapno
https://lnkd.in/gsCz2Vjr


14)Software Engineering is Becoming Position-Less By Gregor Ojstersek
https://lnkd.in/gy32aQfx

15) Random UUIDs are killing your database performance By Mayank A.:
https://lnkd.in/gPu-E_ZS

16)learn these 15 case studies in 2026, ,✨ By Neo Kim :https://lnkd.in/g9Y2nisn

17)A Single Subscriber Doesn’t Turn Pub/Sub Into a Queue By Raul Junco:https://lnkd.in/gTtMFS92

18)10 Must-Know Database Types for System Design Interviews:
: by Ashish Pratap Singh:https://lnkd.in/gWNbpuqN

19)If you want to get started with computer vision, OpenCV is the tools: By Fernando Franco:https://lnkd.in/gWEbD-Xk

20) Why AI Needs GPUs and TPUs? By Alex Xu
https://lnkd.in/ghuRfBPR

21)If your LLM can't connect facts across documents, 
 by Nina Fernanda Durán
https://lnkd.in/gz5RSTfc

22)What actually happens when you invoke an AWS Lambda? By sukhad anand
https://lnkd.in/gsEdK-S6

23)Career tip: You don’t need much to be a great developer. By Daniel Moka: 
https://lnkd.in/ghT77Myj

24)🎯The Moment I Knew I Was Leading Wrong
 Abhishek Kumar:https://lnkd.in/gbQPcPmj

25)One of the most useful things I learned as a manager was how to end
.By Taha Hussain:https://lnkd.in/gq55gHiN

26) Understanding how the CPU works and how to write thread-efficient programs is very important. 
 By Mahesh Mallikarjunaiah ↗️
https://lnkd.in/gn6QbNqx

27)Every engineer I know is chasing the latest AI model.
 by Milan Jovanović https://lnkd.in/g3kD_V4X

28)𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗻𝗲𝘄(𝗲𝘅𝗽𝗿) 𝗶𝗻 𝗚𝗼 𝟭.𝟮𝟲 by Rihab SAKHRI:https://lnkd.in/gWiEa8uP

29)Prompt generator and prompt Improver by Pallavi Ahuja
https://lnkd.in/gjNVmYtd

Senior Software Engineer | content creator| open for collabs| freelancer | 1:1 Career Guidance

Hi LinkedIn Community and Jai Shree Krishna to everyone 🙏✨

Today I revisited an important System Design concept that frequently appears in senior engineering interviews and real world distributed systems architecture API Gateway vs Service Mesh.

As modern applications scale, teams move from monolithic architectures to microservices based systems. Instead of one large application, we now have multiple independent services communicating over the network 🌐.

While this improves scalability and flexibility, it also introduces new challenges in network communication and service management.
When many services communicate across servers, engineers must handle:

1️⃣ Request routing across services
2️⃣ Authentication and authorization
3️⃣ Monitoring and observability
4️⃣ Retries and failure handling
5️⃣ Secure service communication

To manage this complexity, two key architectural components are widely used:

🚪 1️⃣ API Gateway
An API Gateway acts as the single entry point for external client requests.
Clients such as mobile apps, browsers, or third party systems send requests to the gateway first, which then routes them to the correct microservice.
This type of traffic is called North South Traffic (external → internal communication).

Key responsibilities of an API Gateway include:
• Request routing
• Authentication and authorization
• Rate limiting
• API version management
• Logging and monitoring
In simple terms, the API Gateway works as the security shield and traffic controller for the backend system.

🔗 2️⃣ Service Mesh
While API Gateways manage external traffic, microservices also need reliable internal communication.
In large systems, hundreds of services communicate with each other. Managing retries, load balancing, encryption, and observability becomes complex.
A Service Mesh solves this by managing East West Traffic (service to service communication).
Instead of adding networking logic inside services, a Sidecar Proxy is attached to each service to handle:
• Service discovery
• Load balancing
• Retries and circuit breaking
• Observability and tracing
• Secure communication using mTLS
This allows developers to focus on business logic, while the infrastructure layer manages communication.

📌 Quick Summary
1️⃣ API Gateway → North South Traffic (Client → Service)
2️⃣ Service Mesh → East West Traffic (Service → Service)

Both are critical components for building secure, scalable, and resilient distributed systems.
Learning these patterns is extremely valuable for System Design interviews and for building production grade cloud native architectures 🚀

#SystemDesign #Microservices #APIGateway #ServiceMesh
#DistributedSystems #SoftwareEngineering #TechLearning

Hi LinkedIn Community 👋
Jai Shree Krishna to everyone 🙏

One of the most interesting challenges in distributed systems is answering a very simple question:

1)When is a write actually “done”?

Imagine a database storing the same data across three servers in three different cities.

Now suppose a user updates a value.
Is the write complete when:
• the first server saves it?
• two out of three servers confirm it?
• or when all replicas store the new value?

1.1)At first glance this sounds like a small implementation detail, but in reality it defines how trustworthy and reliable a system is.

1.2)💡 Think about a banking example
Suppose you transfer $500 from savings to checking.
You immediately open your banking app and see the updated balance.
But at the same moment, someone checking the same account from another city still sees the old balance.
For a few seconds, the system now has two different versions of the truth.
For something like a social media like counter, this temporary mismatch is harmless.
But for banking systems, financial transactions, stock trading, or inventory management, inconsistent data can cause serious issues.
This is exactly why distributed systems rely on the concept of Strong Consistency.

2)📌 What is Strong Consistency?
Strong consistency guarantees that once a write operation completes, every read in the system will return the most recent value.
No matter where the request comes from

• another server
• another region
• or another data center
the system always returns the latest committed data.
This ensures that all users observe the same state of the system.

2.1)🔎 What the architecture behind it looks like:

The diagram highlights some key building blocks that enable strong consistency.

1️⃣ ACID Properties
Reliable databases rely on the ACID guarantees:
• Atomicity – A transaction either fully succeeds or completely fails.
• Consistency – The database always moves from one valid state to another.
• Isolation – Concurrent transactions behave as if they run sequentially.
• Durability – Once committed, the data survives crashes and failures.
These properties ensure that data integrity is never compromised.

2️⃣ Transaction Lifecycle
Every database transaction moves through stages like:
Begin → Active → Partially Committed → Committed
If anything fails during execution, the transaction safely moves to Failed → Terminated, preventing inconsistent states.

3️⃣ Consensus Algorithms
To keep multiple servers in sync, distributed systems rely on consensus algorithms.
Two widely used examples are:
🔹 Raft
A leader node receives writes and replicates them to followers. A write becomes committed only when a majority of nodes acknowledge it.

🔹 Paxos
Uses roles like proposers, acceptors, and learners to ensure distributed nodes agree on a single value even when failures occur.


Image Credit :ByteByteGo(Alex Xu)

#DistributedSystems #SystemDesign #SoftwareEngineering

Hi LinkedIn community 👋
 Jai Shree Krishna to everyone 🙏
Let’s talk about something that silently powers every massive product we use today 
 Distributed System Architecture.

If you truly understand this, you understand modern backend engineering.

1)🧱 It All Starts Simple
Every application begins with a single database server.
One machine.
 All reads.
 All writes.
 Everything centralized.
At low traffic — it works perfectly.
But as users grow, requests explode.
 CPU hits 100%.
 Memory fills up.
 Latency spikes.
 Eventually… the system crashes.

This approach is called Vertical Scaling  adding more RAM, better CPU, stronger hardware.

But here’s the harsh truth:
A single machine has a physical limit.
And worse — it creates a Single Point of Failure.
If that machine dies → your entire application goes offline.

2)🔄 The Evolution: Horizontal Scaling:

To survive growth, we move from one powerful machine
 to many smaller machines working together.
These machines are called nodes.
 A group of nodes forms a cluster.
To the user, it still looks like one database.
 Behind the scenes, traffic is intelligently distributed.
This is called Horizontal Scaling.

3)Benefits:
Massive scalability
Load distribution
No single bottleneck
High fault tolerance
This is how systems at
 Amazon,
 Netflix, and
 Google
 operate at global scale.

4)🔁 But Here’s the Hidden Problem
When one node receives new data, it must share that data with every other node.
This process is called Replication.
Replication ensures:
Data durability
High availability
Fault tolerance

5)But replication depends on something fragile:
🌐 The Network.
And networks fail.
⚡ The Moment Everything Breaks: Network Partition
Sometimes nodes can’t communicate due to cable failure, router issues, or packet drops.
This is called a Network Partition.

6)Now the system faces a brutal decision:
👉 Should we stop accepting new requests to keep data perfectly consistent?
 OR
 👉 Should we keep accepting requests and risk inconsistent data?

7)This trade-off is governed by the famous:
🧠 CAP theorem
A distributed system can only guarantee two out of three:
Consistency (C) – All nodes return the same data
Availability (A) – Every request gets a response
Partition Tolerance (P) – System continues despite network failures
Since network failures are unavoidable in real-world systems, Partition Tolerance is mandatory.
So the real decision becomes:
CP → Consistency + Partition Tolerance
 or
 AP → Availability + Partition Tolerance
You cannot have all three.
Not because of engineering limitations.

 8)Because of mathematical proof.
🏦 Real-World Trade-Offs
Banking systems → Prefer Consistency (CP)
 Social media feeds → Prefer Availability (AP)
There is no perfect architecture.
There are only informed trade-offs based on business requirements.

#SystemDesign #DistributedSystems #Scalability #BackendEngineering

Hi LinkedIn Community 👋
 Jai Shree Krishna to everyone 🙏

Every second, modern software systems process millions of digital events  payments, searches, messages, video streams, API calls.
But here’s something most people don’t realize:
None of this runs on a single powerful computer.

Because a single machine is:
• Not scalable
 • Not fault-tolerant
 • A guaranteed future failure
Hardware crashes. Disks fail. Networks break. Power goes out.
So how do global systems stay online 24/7?

1)🌍 The Power of Distributed Systems
Modern applications are built on Distributed Systems — where multiple independent machines work together as one logical system.
Instead of one server, engineers build a cluster.
Each machine inside that cluster is called a node.

These nodes continuously:
 • Replicate data
 • Synchronize state
 • Monitor each other’s health
 • Coordinate task execution
 • Distribute traffic

To users, it looks like one reliable database.
Internally, it’s a carefully coordinated network of machines constantly talking to each other.

2)👑 Leader–Follower Model
Most distributed databases follow a Leader–Follower architecture.
One node becomes the Primary Leader:
 • Handles all write operations
 • Processes transactions
 • Maintains the source of truth
Other nodes act as Followers:
 • Replicate the leader’s data
 • Maintain backups
 • Often serve read traffic

3)This structure ensures:
 ✔️ Consistency
 ✔️ Durability
 ✔️ High availability

4)💓 Heartbeats & Self-Healing
The leader continuously sends small signals called heartbeats.
If followers stop receiving them, they assume the leader has failed and automatically trigger a leader election process.
No human intervention needed.
This is how systems self-heal.

5)⚠️ The Real Enemy: Network Partitions
Here’s where things get complex.
Sometimes the leader doesn’t crash.
The network fails.
Routers freeze. Switches malfunction. Cloud networking misroutes packets.
Nodes are alive  but they can’t communicate.
This is called a Network Partition.

6)When this happens:
 • Heartbeats stop
 • Nodes think others are dead
 • The cluster splits
Multiple segments may elect their own leaders.
Now you have conflicting “truths.”
This is the dangerous Split-Brain problem.

7)Result?
 ❌ Data inconsistency
 ❌ Lost transactions
 ❌ Production outages
And yes  this has caused real outages at large tech companies.

7)📚 CAP Theorem: The Hard Trade-Off
Distributed systems can guarantee only two of the following:
• Consistency
 • Availability
 • Partition Tolerance
Since network failures are inevitable, systems must choose:
Consistency or Availability during partitions.
There is no perfect architecture.
Only trade-offs.

And real engineering is building systems that survive failure gracefully 🚀

#DistributedSystems #SystemDesign #BackendEngineering #SoftwareArchitecture #Scalability #CAPTheorem #CloudComputing #TechLeadership

Hi LinkedIn Community and Jai Shree Krishna to everyone 🙏

One fundamental truth in modern software engineering is this:
Computer hardware is inherently unreliable.

1)Inside large data centers, thousands of machines run continuously to power modern applications. But hardware failures are not rare  they are expected.

⚠️ A power supply may fail
⚠️ A memory chip may corrupt data
⚠️ A machine may suddenly stop responding
When a single computer runs an isolated application, a crash is obvious because the entire application simply goes offline.

However, modern applications run on distributed systems where thousands of machines work together.
In these systems, when one machine fails, it does not bring down the entire application. Instead, the failed machine simply becomes silent.
This creates a serious challenge.
The remaining healthy machines do not know that the failed node is dead. They continue sending requests and tasks to that machine.

Those requests disappear into a void.
This can lead to:
❌ Lost tasks
❌ Data inconsistencies
❌ System instability
Detecting these silent failures quickly is one of the most critical aspects of reliable distributed system design.

2)💓 This is where the Heartbeat Mechanism comes in.
A heartbeat is a small network message that a machine sends periodically to prove it is alive and functioning.
Think of it as a digital pulse signal.

For example:
1️⃣ A Worker Node performs processing tasks
2️⃣ A Monitor Node tracks the health of machines
Every few seconds, the worker node sends a small heartbeat message to the monitor node.
As long as the monitor keeps receiving these messages, it knows the worker node is healthy.
If the messages stop arriving, the monitor immediately detects a potential failure and can trigger recovery actions.

3)⚙️ What does a heartbeat message contain?
A typical heartbeat payload includes:
🆔 Node Identifier – tells which machine sent the message
⏱️ Timestamp – when the message was created
📊 Status Code – confirms the internal application is running
The payload must remain small and lightweight so it does not overload the network.

4)🏗️ Push Architecture
In most systems, heartbeats follow a Push Model.
The worker node runs a timer and pushes heartbeat signals to the monitoring service, while the monitor simply listens.
This simple idea powers the reliability of many modern systems including:
✔ Cloud infrastructure
✔ Kubernetes clusters
✔ Microservices platforms
✔ Distributed databases
Sometimes the most powerful engineering solutions are also the simplest.
A tiny message sent every few seconds can determine whether a large distributed system remains stable or fails silently.

#DistributedSystems #SystemDesign #BackendEngineering #SoftwareArchitecture #Microservices #CloudComputing #TechLearning

Hi LinkedIn community, and Jai Shree Krishna to everyone 🙏
2026 has already started with major momentum in AI.

In just the first few months, we’ve seen:
• Moonshot AI open-source Kimi K2.5, a trillion-parameter model built for multimodal agent workflows
• Alibaba release Qwen3-Coder-Next, an efficient coding model designed for agentic development
• OpenAI launch a macOS app for Codex, bringing AI coding assistants closer to everyday workflows
All these developments highlight one clear shift: AI is moving from simple text generation to reasoning, agents, and production-grade systems.
Here are 5 key AI trends that will shape how teams build in 2026:

1️⃣ Reasoning Models & RLVR
Early models like GPT-4 generated answers immediately. But newer reasoning models (like OpenAI’s o1 and DeepSeek-R1) spend time “thinking” before responding.
A key technique behind this progress is Reinforcement Learning with Verifiable Rewards (RLVR).
Instead of relying heavily on human feedback (RLHF), models get rewarded when outputs can be automatically verified  for example when code runs correctly or a math answer matches the ground truth.
This enables training at massive scale and is pushing reasoning capabilities forward rapidly.

2️⃣ Agents & Tool Use
Modern AI systems are evolving into agents that can plan and take actions.
An agent typically:
• Interprets a user request
• Chooses the next step
• Uses tools (APIs, search, files, code execution)
• Evaluates results and iterates
Frameworks like LangChain and LlamaIndex made building agents easier, while protocols like Model Context Protocol (MCP) simplify tool integrations.
But running agents in production requires more than just code.

3️⃣ Orchestrating Agents for Production
Building agents is easy. Running them reliably in production is the real challenge.
As workflows grow, systems need:
• State management
• Retries & error handling
• Observability
• Human-in-the-loop control
• Scalability
Workflow engines like Orkes Conductor provide a durable orchestration layer to coordinate agents, APIs, tools, and human tasks.
Instead of fragile scripts, teams can build structured, fault-tolerant AI workflows.

4️⃣ Coding Agents Transforming Development
AI is moving from simple autocomplete to repo-level engineering assistants.
Modern coding agents can:
• Read entire repositories
• Understand project architecture
• Modify multiple files
• Run tests and debug issues
Tools like Claude Code, Codex, and models like Qwen3-Coder-Next are accelerating development and lowering the barrier to building software.

5️⃣ Rise of Open-Weight Models
The open ecosystem is moving incredibly fast.
After the release of DeepSeek-R1 many labs started releasing strong open-weight models. This allows developers to:
• Run models locally
• Fine-tune them
• Build custom AI systems without relying entirely on APIs

#AI #GenAI #AIAgents #LangChain #MachineLearning #LLM #ArtificialIntelligence #SoftwareEngineering #AIEngineering

🚀 How Agoda Built a Single Source of Truth for Financial Data
Every day, millions of financial data points flow through Agoda’s ecosystem  sales, costs, revenue, margins, reconciliations, general ledger entries, forecasts, and strategic planning metrics.

1)These numbers don’t just sit in dashboards.
 They drive executive decisions.
 They define financial health.
 They influence investor confidence.

2)But here’s the challenge 👇
As Agoda scaled, different teams  Data Engineering, Business Intelligence, and Data Analytics  built their own data pipelines to serve their specific needs.

3)At first, this made sense.
Separate pipelines meant:
 ✔️ Faster development
 ✔️ Clear ownership
 ✔️ Flexibility for team-specific use cases
 ✔️ Simpler architecture
But over time, something subtle  and dangerous  started happening.
⚠️ The Hidden Cost of Multiple Financial Pipelines

4)When financial data is processed through multiple independent systems, complexity multiplies quietly.

4.1️⃣ Duplicate Sources & Redundant Processing
Multiple teams pulling from the same upstream booking systems — but at slightly different times, with slightly different queries — led to:
Redundant computation
Increased infrastructure cost
Synchronization mismatches
Different “versions” of the same data
Three teams. One database. Three answers.
Not ideal for finance.

4.2️⃣ Inconsistent Metric Definitions
This is where trust starts breaking.
Each team applied its own business logic and transformation rules.
For example:
Revenue calculated differently by Finance vs Analytics
Margins computed with slightly different assumptions
Timing differences in recognition logic
Now imagine an executive asking:
 “What was our net revenue last quarter?”
And getting different answers depending on the dashboard.
That’s not a data problem.
 That’s an organizational risk. ⚡

4.3️⃣ No Unified Monitoring & Quality Governance
Without centralized observability:
Each team built its own validation checks
Quality standards varied
Incident detection was delayed
Root cause analysis became complicated
When something broke, the real question became:
 “Which pipeline is wrong?”
And that’s not a question you want during financial reporting cycles.

5)🧠 The Realization
Agoda recognized a critical truth:
Financial data cannot afford ambiguity.
In finance, there must be one definition of revenue, one definition of cost, one definition of margin.
A company of Agoda’s scale needs a Single Source of Truth (SSOT)  a centralized, governed, trusted financial data platform.

6)🏗️ The Shift: Building a Unified Financial Data Platform
To solve these challenges, Agoda’s engineering team moved toward:
✅ Centralized financial data models
 ✅ Standardized metric definitions across teams
 ✅ Shared transformation logic
 ✅ Strong data governance & ownership clarity
 ✅ Unified monitoring and quality controls
 ✅ Reduced duplication at ingestion layer

#DataEngineering #SystemDesign #AnalyticsEngineering #FinanceTech

taplio

The Battle

Addy Osmani

Kartik Kaushik

Followers

Posts

Engagements

Likes

Performance ScoreAddy Osmani's LinkedIn Performance

Performance ScoreKartik Kaushik's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Addy Osmani

Kartik Kaushik

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Addy Osmani's LinkedIn Performance

Performance ScoreKartik Kaushik's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreAddy Osmani's LinkedIn Performance