Canva

Engineering Manager

Level Up Coding

Co-Founder

LoyPal - Applied Customer Intelligence

Senior Software Engineer

Future Amp

Product Lead

Myagi

Full Stack Engineer

Intern

My goal has always been to empower engineers to grow and reach new heights. This passion has led me to become an Engineering Manager at Canva and Co-Founder of Level Up Coding.

🚀 Level Up Coding is on a mission to fast-track how engineers learn and revise engineering concepts by providing education that’s engaging, accessible, and simple to understand. We're here to empower developers to level up their skills and careers to the next level and beyond.

At Level Up Coding, we believe that visual learning is a powerful tool for mastering engineering concepts. We leverage the power of design, animation, and creativity to make concepts more accessible, engaging, and easier to learn.

💡 I’ve had the privilege of working with amazing talent throughout my career and experiencing career growth at a pace beyond my wildest expectations. There’s a formula for engineers to grow rapidly; I’ve lived it and taught it. I’ve been distilling this formula into a course to help engineers unlock their career potential at scale. Stay tuned.

Newsletter: https://blog.levelupcoding.com 

X/Twitter: https://x.com/NikkiSiapno 

LUC X/Twitter: https://x.com/LevelUpCoding_ 

LUC LinkedIn: https://www.linkedin.com/company/levelupcoding

🤝 If you want to collaborate, reach out to me on LinkedIn.

How do we design effective and safe APIs? 

APIs have increasingly become the backbone of modern software.

𝗧𝗼 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱 some of the 𝗸𝗲𝘆 𝗽𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 and 𝗯𝗲𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 𝗼𝗳 𝗔𝗣𝗜 𝗱𝗲𝘀𝗶𝗴𝗻, Let's 𝗮𝗻𝗮𝗹𝘆𝘇𝗲 𝗮 𝘀𝗼𝗰𝗶𝗮𝗹 𝗺𝗲𝗱𝗶𝗮 𝗽𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗲𝘅𝗮𝗺𝗽𝗹𝗲:

🔹 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗻𝗮𝗺𝗶𝗻𝗴
↳ Clarity is key when creating APIs. Adopting simple resource names, like /users for accessing user profiles and /posts for retrieving user posts, streamlines the development process and reduces mental strain.

🔹 𝗨𝘀𝗲 𝗼𝗳 𝗽𝗹𝘂𝗿𝗮𝗹𝘀
↳ It's important to maintain a standard of consistency in API design. For consistency and readability, use plural resource names, such as GET /users/{userId}/friends vs. /friend), to avoid ambiguity in API requests.

🔹 𝗖𝗿𝗼𝘀𝘀-𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗶𝗻𝗴 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀
↳ Interlinking resources, like taking comments on a post using GET /posts/{postId}/comments, simplifies the retrieval of related data. It provides a more streamlined and well-organized user experience.

🔹 𝗜𝗱𝗲𝗺𝗽𝗼𝘁𝗲𝗻𝗰𝘆
↳ Maintaining API reliability is crucial. Idempotency ensures that operations like profile updates (PUT /users/{userId}/profile) produce the same result no matter how many times it’s executed.

Learn more about idempotency here: https://lnkd.in/g_f8eSfh

🔹 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆
↳ It goes without saying, security is a must-have. To secure the API endpoints, employ authentication methods like X-AUTH-TOKEN and X-SIGNATURE, and use authorization headers for verifying user permissions.

🔹 𝗩𝗲𝗿𝘀𝗶𝗼𝗻𝗶𝗻𝗴
↳ Communicating version updates is another important practice. Endpoints like GET /v2/users/{userId}/posts allow API versioning to maintain functionality regardless of updates. This approach ensures backward compatibility and a smooth transition for users and us.

🔹 𝗣𝗮𝗴𝗶𝗻𝗮𝘁𝗶𝗼𝗻
↳ Important for performance. Paginate large datasets, like feeds or comment lists, with GET /posts?page=5&pageSize=20 to enhance data delivery and UX.

Great APIs come from good practices. Clear docs, strong monitoring, consistent error handling, and more. Adopting these practices helps us build secure, performant APIs that deliver great user experiences.

What else would you add?

--
👋 PS: If you like this post, then you'll love our newsletter. Join 25,000+ software engineers: https://lnkd.in/gu4pUvAg

PPS: You get our Architecture Patterns Playbook for free when you join. It’s packed with visuals, tradeoffs, & real-world examples.

--
🔖 Save for later • ♻️ Repost to help others
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

Nikki Siapno

Founder | Eng Manager | ex-Canva | 400k+ audience | Helping you become a great engineer and leader

The Main Components of Kubernetes Explained.

At its core, Kubernetes is built on a handful of key components, each with a distinct role.

By understanding them, you'll have a strong foundational understanding.

𝗡𝗼𝗱𝗲:
↳ Machines (physical or virtual) that run containerized applications. Nodes host the workload, which is composed of Pods.

𝗣𝗼𝗱:
↳ The smallest deployable unit in K8s, containing one or more containers that share storage, networking, and resources.

𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗽𝗹𝗮𝗻𝗲:
↳ The "brain" of the cluster that manages system state and oversees Nodes and Pods. 

It consists of:

• API server: handles cluster management requests
• Scheduler: assigns Pods to Nodes
• Controller manager: maintains the desired state
• etcd: stores cluster configuration and state as a distributed key-value store

𝗦𝗲𝗿𝘃𝗶𝗰𝗲:
↳ Provides stable endpoints (IP/DNS) to enable communication between Pods or expose applications to external users.

𝗜𝗻𝗴𝗿𝗲𝘀𝘀:
↳ Manages external HTTP/HTTPS traffic, routing it to the appropriate services within the cluster.

𝗡𝗮𝗺𝗲𝘀𝗽𝗮𝗰𝗲:
↳ A virtual cluster within a Kubernetes cluster, allowing for resource isolation and multi-tenancy.

𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝘃𝗼𝗹𝘂𝗺𝗲:
↳ Decouples storage from Pods, enabling data persistence across container restarts or deletions.

The components above work together to form a powerful system for automating application orchestration. Kubernetes has become the go-to platform for ensuring reliability and scalability in modern software systems. That said it's not the answer for every application. There's a steep learning curve and complexity involved. Sometimes simpler/lightweight options like Docker Swarm or PaaS solutions are a better fit.

What else would you add?

--
Thanks to Oracle who keeps our content free to the community.

𝗗𝗶𝗱 𝘆𝗼𝘂 𝗵𝗲𝗮𝗿 about the autonomous AI database release? There’s also a 𝗳𝗿𝗲𝗲 𝘁𝗶𝗲𝗿.

Check it out (for free): https://lnkd.in/gg4QSV83

--
💾 Save for later.
♻️ Repost to help other engineers grow.
🙋🏻‍♀️ Follow Nikki Siapno, turn on notifications.

Concepts every developer should know: concurrency is 𝗡𝗢𝗧 parallelism.

Parallelism and concurrency are two terms that often create confusion.

One is about managing multiple tasks at once, intermixing them to optimize resource usage.

The other involves executing multiple tasks simultaneously.

As Rob Pike (one of the creators of Golang) succinctly put it: “𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 is about 𝐝𝐞𝐚𝐥𝐢𝐧𝐠 𝐰𝐢𝐭𝐡 lots of things at once. 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹𝗶𝘀𝗺 is about 𝐝𝐨𝐢𝐧𝐠 lots of things at once."

What else would you add?

👋 PS: Want to dive deeper? We covered this topic in detail in our newsletter (with visuals): https://lnkd.in/gjjXDneg

--
🔖 Save for later • ♻️ Repost to help others
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

Founder of LUC | ex-Engineering Manager at Canva

Stateful vs Stateless Design.

Stateless design is a powerful model that has led to the development of simple yet highly scalable and efficient applications.

“State” refers to stored information that systems use to process requests. This information can change over time as users interact with the application or as system events occur.

𝗪𝗵𝗮𝘁 𝗮𝗿𝗲 𝘀𝘁𝗮𝘁𝗲𝗳𝘂𝗹 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀?

Stateful applications store data like user IDs, session information, configurations, and preferences to help process requests for a given user. A stateful design allows applications to provide a personalized experience to their users while removing the need to share data across multiple requests.

𝗧𝗵𝗲 𝗯𝗶𝗿𝘁𝗵 𝗼𝗳 𝘀𝘁𝗮𝘁𝗲𝗹𝗲𝘀𝘀 𝗱𝗲𝘀𝗶𝗴𝗻

As applications grew in complexity and received increasing amounts of traffic, the limitations of stateful design became apparent. Managing and maintaining session data adds significant performance overhead and complexity to a system. This complexity made it difficult for systems to scale horizontally as sharing state across multiple instances becomes a challenge.

The rapid need for scalability and efficiency drove the popularity of stateless design. Instead of having mechanisms for state management, requests contained all the information needed to process it. This allowed systems to handle high levels of requests while adding flexibility to how the system scales, making it more resource efficient.

The key applications of stateless design have been pivotal in several areas:

↳ Microservices & serverless computing: they exemplify statelessness, enabling services and functions to operate independently, thus enhancing scalability & resource efficiency.

↳ RESTful APIs & CDNs: by each API call or request containing all necessary information, stateless design simplifies operations & improves content delivery speeds.

However, stateless design also presents certain challenges:

• Larger request sizes: the need to include complete data in each request can result in increased data transfer, affecting performance.

• Transmission inefficiencies: constantly sending full data sets can be less efficient than accessing centralized data in stateful designs.

• Not always ideal: in scenarios inherently requiring state, such as complex user interactions, stateless design can add more complexity instead of simplifying the process.

𝗠𝗼𝘀𝘁 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝗽𝗶𝗰𝗸 𝗮 𝗵𝘆𝗯𝗿𝗶𝗱 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 between stateful and stateless design depending on the needs and constraints of each component. The key to a well-designed system is balance. It should be scalable, simple, & fast without sacrificing functionality.

--
Thanks to Tiger Data who keeps our content free to the community.

Agentic Postgres just released. It’s Postgres, for the AI era. There’s also a free tier.

Check it out (for free): https://lnkd.in/gWJ8QPpu

--
🔖 Save for later
♻️ Repost to help others learn system design

Founder LUC | Eng Manager | ex-Canva | 400k+ audience | Helping you become a great engineer and leader

API Gateway vs Load Balancer — What's the Difference?

An 𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 acts as a single entry point for clients, handling request routing, composition, and protocol translation. It simplifies client interactions with microservices and offers features like rate limiting, authentication, monitoring, and more.

𝗟𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗲𝗿𝘀 are concerned with routing client requests across multiple servers to distribute load and prevent bottlenecks. This helps maximize throughput, reduce response time, and optimize resource use.

So what are the key differences?

API gateways focus on request management and microservice communication, while Load Balancers focus on traffic distribution and server load management.

API gateways operate at the application layer (L7), while Load Balancers can operate at both transport (L4) or application (L7) layers.

API gateways offer features like routing, rate limiting, authentication, service discovery, parameter validation, circuit breakers, and more. Load Balancers handle traffic distribution and failover.

An 𝗔𝗣𝗜 𝗴𝗮𝘁𝗲𝘄𝗮𝘆 𝗶𝘀 𝗜𝗱𝗲𝗮𝗹 𝗳𝗼𝗿 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲𝘀 needing centralized API request management.

A 𝗹𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗲𝗿 𝗶𝘀 𝗲𝘀𝘀𝗲𝗻𝘁𝗶𝗮𝗹 𝗳𝗼𝗿 applications requiring high availability, distributing traffic across multiple servers.

In summary, API gateways manage and secure API calls, while load balancers ensure efficient traffic distribution.

What else would you add?

--
Thanks to WorkOS who keeps our content free to the community.

𝗗𝗶𝗱 𝘆𝗼𝘂 𝗸𝗻𝗼𝘄 AuthKit offers a 𝗳𝗿𝗲𝗲 𝘁𝗶𝗲𝗿 𝘂𝗽 𝘁𝗼 𝟭 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 𝘂𝘀𝗲𝗿𝘀? It makes auth super simple.

Check it out: https://lnkd.in/gWimVs-g

--
🔖 Save for later
♻️ Repost to help others learn system design
🙋🏻‍♀️ Follow Nikki Siapno for more

Must-know principles of solution architecture design
(explained in under 2 mins):

𝟳 𝗰𝗼𝗿𝗲 𝗽𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝘄𝗶𝘁𝗵 𝗮𝗰𝘁𝗶𝗼𝗻𝗮𝗯𝗹𝗲 𝗯𝗲𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 for designing solutions:

𝗛𝗶𝗴𝗵𝗹𝘆 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲 𝗮𝗻𝗱 𝗿𝗲𝘀𝗶𝗹𝗶𝗲𝗻𝘁
↳ High availability ensures systems stay operational despite failures; resilience enables fast recovery.
↳ Use active-passive or active-active failover setups to minimize downtime. Build redundancy and synchronize data where needed to maintain continuity during disruptions.

𝗦𝗰𝗮𝗹𝗮𝗯𝗹𝗲
↳ Systems must handle growth without degrading performance. 
↳ Vertical scaling adds resources to a node, but horizontal scaling (adding nodes) with load balancers offers better flexibility. Use auto-scaling and manage state (e.g. distributed caches) to handle traffic spikes efficiently.

𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝘁
↳ Performance optimization reduces latency and maximizes throughput.
↳ Apply non-blocking I/O, asynchronous processing, and caching to handle concurrency. Use p99 latency metrics to monitor worst-case scenarios and maintain a consistent user experience.

𝗦𝗲𝗰𝘂𝗿𝗲
↳ Security must be embedded throughout. Implement end-to-end encryption, RBAC, and threat modelling to address risks proactively.
↳ Use OAuth2 or JWT for authentication, and consider Zero Trust Architecture (ZTA) to ensure continuous identity verification.

𝗟𝗼𝗼𝘀𝗲𝗹𝘆 𝗰𝗼𝘂𝗽𝗹𝗲𝗱
↳ Modular systems scale and adapt more easily.
↳ Use event-driven architectures and asynchronous messaging systems (e.g. Kafka, RabbitMQ) to decouple dependencies. This ensures scalability, fault tolerance, and seamless updates.

𝗘𝘅𝘁𝗲𝗻𝗱𝗮𝗯𝗹𝗲
↳ Extendable systems grow smoothly over time.
↳ Follow the open-closed principle (OCP) to allow new features without modifying core functionality. Ensure API-first designs are backward compatible to support new integrations without disruptions.

𝗥𝗲𝘂𝘀𝗮𝗯𝗹𝗲
↳ Reusable components accelerate development and improve maintainability.
↳ Design with composability, using shared libraries, SDKs, or reusable components. Apply domain-driven design (DDD) to promote reusability across business domains.

By following these principles, we can build systems that meet today’s demands while staying adaptable to future challenges. Thoughtful architecture ensures scalability, security, and resilience while supporting continuous innovation.

--
Thanks to Oracle who keeps our content free to the community.

Did you hear about the Oracle26ai release? There’s also a free tier.

Check it out (for free): https://lnkd.in/gg4QSV83

--
🔖 Save this for later.
♻️ Repost it to help others learn system design.
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

API performance techniques
(explained in under 2 mins):

API inefficiencies not only degrade the user experience but also increase operational costs through increased resource consumption and downtime.

Here are 5 𝗽𝗼𝗽𝘂𝗹𝗮𝗿 𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻𝘀 𝘁𝗼 𝗶𝗺𝗽𝗿𝗼𝘃𝗲 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲:

↗ 𝗣𝗮𝗴𝗶𝗻𝗮𝘁𝗶𝗼𝗻
By dividing data into distinct, sequentially numbered pages, pagination helps handle large datasets by enabling APIs to effectively provide fewer results.

This technique not only accelerates data access but also optimizes resource utilization, making the process of managing large datasets both practical and efficient.

↗ 𝗖𝗮𝗰𝗵𝗶𝗻𝗴
Important for improving performance optimization since it stores frequently retrieved data.

The client can query the cache first, decreasing direct database queries and preserving resources.

Cache misses are properly managed by refreshing the cache upon new data queries, ensuring that the database is not overwhelmed with repeated calls, improving API response times.

↗ 𝗣𝗮𝘆𝗹𝗼𝗮𝗱 𝗰𝗼𝗺𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻
Compression algorithms like gzip reduce data size, which is critical for optimizing API interactions.

This approach accelerates the transport of data, both for uploads and downloads, considerably improving the responsiveness of our APIs.

The user experience is much improved, and the effect is particularly apparent over slower connections.

↗ 𝗔𝘀𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗼𝘂𝘀 𝗹𝗼𝗴𝗴𝗶𝗻𝗴
Another key technique for preserving API performance since it enables system activity monitoring without slowing down operations.

Using a lock-free ring buffer for log management improves throughput and decreases latency, resulting in decreased I/O overhead and faster and more efficient API operations.

↗ 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻 𝗽𝗼𝗼𝗹𝗶𝗻𝗴
Efficiently manages database interactions by maintaining a pool of open connections for reuse, significantly reducing the overhead of opening and closing connections for each request.

This strategy enhances application performance through faster response times and optimized resource utilization, ensuring scalability and reliability by preventing DB overload.

What else would you include?

--
👋 PS: If you like this post, then you'll love our newsletter. Join 25,001+ software engineers: https://lnkd.in/gu4pUvAg

 PPS: You get our Architecture Patterns Playbook for free when you join. It’s packed with beautifully designed visuals, tradeoffs, & real-world examples.

--
🔖 Save for later.
♻️ Repost to help others learn system design.
🙋🏻‍♀️ Follow Nikki Siapno, turn on notifications.

If I had to build auth,
here's what I'd consider:

Building auth properly means you need to:

1) Integrate with OAuth providers
2) Build signup, password reset, CAPTCHA flows
3) Support SAML, SSO, account recovery

4) Implement rate-limiting and 2FA
5) Detect fraud and secure sessions
6) Handle edge cases when switching auth methods

7) Build internal tools for customer support
8) Ensure CSRF protection and secure cookie handling
9) Support passkeys and biometric login (WebAuthn)
10) And more ...

It's a lot. Especially to be enterprise-ready.

That's why auth and identity providers are so popular. And they're the route I'd take.

WorkOS is one of the most popular choices among SaaS teams.

It offers a free tier up to 1 million users, and implementation is super simple with AuthKit.

Try it out: https://lnkd.in/gNgDxTuv

Thanks to WorkOS for making auth simple and fast, and partnering on this post.

What else should make the auth JTBD list?

--
🔖 Save for later • ♻️ Repost to help others
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

If you want to get started with system design,
learn these 15 concepts:

1) Idempotency in API Design:
↳ https://lnkd.in/gj5YZCKs

2) How JWT Works:
↳ https://lnkd.in/gdF2ce3K

3) SQL vs NoSQL:
↳ https://lnkd.in/gVvBWQRc

4) Service Discovery in Distributed Systems:
↳ https://lnkd.in/gQnHtbRV

5): Message Queues Explained:
↳ https://lnkd.in/g6SEbyJb

6): How Observability Turns Alerts Into Insight:
↳ https://lnkd.in/gdvfWN-Y

7) WebSockets Explained:
↳ https://lnkd.in/gRzQzNbe

8) Change Data Capture (CDC):
↳ https://lnkd.in/giRj-4Sk

9) Principles of Solution Architecture Design:
↳ https://lnkd.in/geMf3pDR 

10) PACELC Theorem:
↳ https://lnkd.in/gcVSBkYW

11) ACID transactions:
↳ https://lnkd.in/gfcEq7VC

12) Forward vs Reverse Proxy:
↳ https://lnkd.in/gtudmXdz

13) Strong vs Eventual Consistency:
↳ https://lnkd.in/gDzHf3CF

14) How HTTPS Works:
↳ https://lnkd.in/gS-Q9jBn

15) API Gateway vs Load Balancer:
↳ https://lnkd.in/gTrdsB-i

What else would you include?

--
🔖 Save for later.
♻️ Repost to help others learn system design.
🙋🏻‍♀️ Follow Nikki Siapno + turn on notifications.

What makes an API RESTful?
(explained in 2 mins or less):

Representational State Transfer (REST) is an architectural style that is commonly used for web-based APIs alongside HTTP as the transport protocol.

Key concepts:

• 𝗦𝘁𝗮𝘁𝗲𝗹𝗲𝘀𝘀: The server shouldn’t need to store any information about a user between requests. Everything that the server needs to execute a task should be sent in the request.

• 𝗦𝗲𝗽𝗮𝗿𝗮𝘁𝗶𝗼𝗻 𝗼𝗳 𝗰𝗼𝗻𝗰𝗲𝗿𝗻𝘀: The client and server should function independently of each other.

• 𝗖𝗮𝗰𝗵𝗲𝗮𝗯𝗹𝗲: Responses can be cached on the client to boost performance.

• 𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝗶𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲: By using HTTP methods like GET, POST, and DELETE, API interfaces stay consistent.

• 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲-𝗯𝗮𝘀𝗲𝗱: RESTful APIs have an emphasis on resources rather than methods or functions. A resource can be an object, entity, or data within a system. Resources are uniquely identified using a Uniform Resource Identifier (URI).

• 𝗦𝘁𝗮𝗻𝗱𝗮𝗿𝗱 𝗺𝗲𝗱𝗶𝗮 𝘁𝘆𝗽𝗲𝘀: Responses are usually sent as JSON, XML, or plain text. Clients can request a preferred media type.

By providing guidelines like statelessness, separation of concerns, and standardized interfaces, REST has made it easier to develop scalable, stable, high-performing applications.

What else would you add?

--
👋 PS: If you like this post, then you'll love our newsletter. Join 25,000+ software engineers: https://lnkd.in/gu4pUvAg

PPS: You get our Architecture Patterns Playbook for free when you join. It’s packed with visuals, tradeoffs, & real-world examples.

--
🔖 Save for later • ♻️ Repost to help others
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

API Gateway vs Load Balancer vs Reverse Proxy
(explained in under 2 mins):

• Load Balancer
↳ Distributes incoming traffic across multiple servers to ensure reliability and performance.

• Reverse Proxy
↳ Sits in front of servers, forwarding requests while hiding server identities. Provides load balancing, security, and caching.

• API Gateway
↳ Centralizes and secures requests, providing a single entry point to services.

All three control how requests reach your backend.
Each has its strengths and tradeoffs.
And each has its use cases.

The best tool? There isn't one.
Choose based on your system's specific needs.

What else would you add?

--
👋 PS: If you like this post, then you'll love our newsletter. Join 25,000+ software engineers: https://lnkd.in/gu4pUvAg

PPS: You get our Architecture Patterns Playbook for free when you join. It’s packed with visuals, tradeoffs, & real-world examples.

--
🔖 Save for later • ♻️ Repost to help others
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

If you want to scale a database,
consider these strategies:

Before you implement scaling solutions, an important principle should be kept in mind. 

𝗔𝘃𝗼𝗶𝗱 𝗽𝗿𝗲𝗺𝗮𝘁𝘂𝗿𝗲 𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻 or scaling your database before it’s necessary. 

Scaling introduces complexities like slower feature development, increased system complexity, harder testing, and harder debugging.

Accept these trade-offs only if your app is at capacity. 

Keep your system simple and scale only when genuinely needed.

With that in mind, let's look at 4 of the top scaling strategies.

𝟭 ) 𝗖𝗮𝗰𝗵𝗲 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗾𝘂𝗲𝗿𝗶𝗲𝘀
↳ One of the simplest improvements you can make to handle database load. Reduce load by caching frequently requested query results. Tools like Redis or Memcached store these results in memory, allowing your app to fetch data faster without hitting the database repeatedly.

𝟮) 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗶𝗻𝗱𝗲𝘅𝗲𝘀
↳ Another straightforward strategy that delivers outsized performance benefits. Indexing accelerates data retrieval by enabling quick data location without scanning every row. Typically implemented with B-trees, indexes reduce data access time complexity from O(n) to O(log n). Significantly faster queries.

𝟯) 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗿𝗲𝗮𝗱 𝗿𝗲𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻
↳ In read-heavy environments, replication may be the next best stone to turn. With read replication, you have a single database that you write to. It's cloned into several (as many as you need) replica databases that you read from. With each replica database sitting on another machine.

𝟰) 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝘀𝗵𝗮𝗿𝗱𝗶𝗻𝗴
↳ While the previous strategies focus on handling read load, sharding focuses on reads and writes. Sharding involves splitting your database into smaller, independent pieces (shards), with each handling a subset of the data. This enables horizontal scaling by distributing the load across multiple servers. While powerful, sharding adds significant complexity to data management and query logic. Typically a strategy you only want to consider after exhausting other simpler solutions.

Your traffic patterns should guide your decisions.
Remember, there’s no perfect answer, only trade-offs.

What else would you add?

--
♻️ Repost to help others learn system design
🙋🏻‍♀️ Follow Nikki Siapno + turn on notifications
🔖 Save for later

How Does SSH Work?

What actually happens when you type ssh user@host?

SSH (Secure Shell) is a network protocol used to securely connect to remote machines over an unsecured network. It ensures confidentiality, integrity, and authentication for remote access, file transfers, and command execution, protecting data from eavesdropping and tampering.

The visual below lays out the sequential steps that occur between the SSH client and the SSH server.

Here’s a breakdown of the main events that occur during an SSH connection:

𝟭) 𝗞𝗲𝘆 𝗲𝘅𝗰𝗵𝗮𝗻𝗴𝗲

SSH begins with a key exchange process, typically using the Diffie-Hellman algorithm. The client and server exchange public components to derive a shared secret, creating a secure session key for encrypted communication without transmitting sensitive private keys.

𝟮) 𝗦𝗲𝗿𝘃𝗲𝗿 𝘃𝗲𝗿𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻

The client validates the server’s identity by checking its public key against a locally stored known_hosts file. This prevents man-in-the-middle (MITM) attacks, ensuring the connection is established only with a trusted server.

𝟯) 𝗦𝗲𝘀𝘀𝗶𝗼𝗻 𝗸𝗲𝘆 & 𝗲𝗻𝗰𝗿𝘆𝗽𝘁𝗶𝗼𝗻 𝘀𝗲𝘁𝘂𝗽

After establishing the shared secret, SSH derives a symmetric session key. This key encrypts all subsequent communication, providing both confidentiality (data remains private) and integrity (modifications are detected). Symmetric encryption is computationally efficient, making it ideal for ongoing communication.

𝟰) 𝗖𝗹𝗶𝗲𝗻𝘁 𝗮𝘂𝘁𝗵𝗲𝗻𝘁𝗶𝗰𝗮𝘁𝗶𝗼𝗻

The client proves its identity through authentication methods, such as public key authentication. In this method, the client signs a server-provided challenge with its private key. The server verifies the signature using the client’s public key, ensuring secure and tamper-proof authentication without exposing the private key.

What else would you add?

--
Thanks to our partner WorkOS who keeps our content free to the community.

AuthKit makes auth super simple.
And they offer a 𝗳𝗿𝗲𝗲 𝘁𝗶𝗲𝗿 𝘂𝗽 𝘁𝗼 𝟭 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 𝘂𝘀𝗲𝗿𝘀.

Try it out: https://lnkd.in/gWimVs-g

--
🔖 Save for later • ♻️ Repost to help others
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

HTTP 2 vs HTTP 3: What's the Difference?

• 1996 → HTTP 1 
• 1997 → HTTP 1.1
• 2015 → HTTP 2
• 2022 → HTTP 3

But what’s the difference? Starting at the foundation:

🔹 𝗛𝗧𝗧𝗣 𝟭.𝟭:

☑ 𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 — Reuses connections instead of opening new ones
☑ 𝗖𝗵𝘂𝗻𝗸𝗲𝗱 𝘁𝗿𝗮𝗻𝘀𝗳𝗲𝗿𝘀 — Sends data in parts instead of waiting for the full response
☑ 𝗜𝗺𝗽𝗿𝗼𝘃𝗲𝗱 𝗰𝗮𝗰𝗵𝗶𝗻𝗴 — Introduced headers for better caching and connection management
🅇 𝗦𝗲𝗾𝘂𝗲𝗻𝘁𝗶𝗮𝗹 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 — Requests block each other (HoL blocking at the request level)
🅇 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝗻𝗲𝗲𝗱𝗲𝗱 — Browsers used multiple TCP connections for speed

It introduced core features still used today.

🔹 𝗛𝗧𝗧𝗣 𝟮:

☑ 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗲𝘅𝗶𝗻𝗴 — Multiple requests in a single TCP connection
☑ 𝗛𝗲𝗮𝗱𝗲𝗿 𝗰𝗼𝗺𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 (𝗛𝗣𝗔𝗖𝗞) — Reduces metadata size
☑ 𝗦𝘁𝗿𝗲𝗮𝗺 𝗽𝗿𝗶𝗼𝗿𝗶𝘁𝗶𝘇𝗮𝘁𝗶𝗼𝗻 — Ensures critical resources load first
🅇 𝗛𝗲𝗮𝗱-𝗼𝗳-𝗹𝗶𝗻𝗲 (𝗛𝗼𝗟) 𝗯𝗹𝗼𝗰𝗸𝗶𝗻𝗴 — A lost packet blocks all streams

While HTTP 2 optimized TCP, it remained constrained by TCP’s head-of-line blocking.

🔹 𝗛𝗧𝗧𝗣 𝟯:

☑ 𝗕𝘂𝗶𝗹𝘁 𝗼𝗻 𝗤𝗨𝗜𝗖 (𝗨𝗗𝗣) — No more TCP bottlenecks
☑ 𝗜𝗻𝗱𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝘁 𝘀𝘁𝗿𝗲𝗮𝗺𝘀 — Packet loss in one stream doesn’t affect others
☑ 𝗙𝗮𝘀𝘁𝗲𝗿 𝗵𝗮𝗻𝗱𝘀𝗵𝗮𝗸𝗲𝘀 — Combines transport + encryption setup in one step
☑ 𝗠𝗮𝗻𝗱𝗮𝘁𝗼𝗿𝘆 𝗲𝗻𝗰𝗿𝘆𝗽𝘁𝗶𝗼𝗻 (𝗧𝗟𝗦 𝟭.𝟯) — Security by default
☑ 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻 𝗺𝗶𝗴𝗿𝗮𝘁𝗶𝗼𝗻 — Seamless across network changes

𝗜𝗻 𝗮 𝗻𝘂𝘁𝘀𝗵𝗲𝗹𝗹: HTTP 2 optimized TCP, but HTTP 3 rewrites the game with QUIC, making it faster, more reliable, and encrypted by default.

Which fact surprised you?

--
👋 PS: If you like this post, then you'll love our newsletter. Join 25,001+ software engineers: https://lnkd.in/gu4pUvAg

 PPS: You get our Architecture Patterns Playbook for free when you join. It’s packed with beautifully designed visuals, tradeoffs, & real-world examples.

--
💾 Save for later.
♻️ Repost to help other engineers grow.
🙋🏻‍♀️ Follow Nikki Siapno, turn on notifications.

AI-native database clearly explained.

A major shift in data architecture is quietly emerging. Traditional databases were built for humans.

AI-native databases are purpose-built for AI systems and agents.

An AI-native database is one that can:

• Understand meaning (semantic/vector/hybrid search)
• Store long-term agent memory/state
• Handle time (event + time-series data)
• Enable parallel experiments in sandboxes

This gives agents the retrieval, memory, and context they need to operate intelligently on your system’s data in isolated environments that mirror production.

And it wraps all of this into a single engine.

One of the first enterprise-grade systems to unify all of this into one engine was just released: Oracle AI Database 26ai.

And there's also a free tier.
You get 2 CPUs, 2 GB of RAM, and 12 GB of storage.

Try it out: https://lnkd.in/gg4QSV83

Thanks to Oracle for collaborating on this post.

What else would you add?

--
🔖 Save for later • ♻️ Repost to help others learn
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

Open Source now rivals closed AI coding tools.

(No.1 on OpenRouter, 13k stars, built by GitLab founder):

We now have an open-source coding agent that can compete with proprietary tools.

• 500+ available models
• No markups on model API pricing
• Pay only for what you use

And here’s a design choice that really stands out:

Most coding agents support two modes.
An “agentic” mode for writing code.
An “ask” mode for chatting without making changes.

Kilo Code supports 5 modes that work together:

↳ Architect mode: handles research, design & planning
↳ Code mode: implements the actual code
↳ Ask mode: talk with the model without actions
↳ Debug mode: diagnose issues and work through fixes
↳ Orchestrator mode: coordinates all agents to complete tasks

Teams? Enterprise? All the features you'd want on both tiers.
Centralized billing, org-wide governance, team management, shared context, and more.

For individuals, it's free.
And for teams, there's a free trial (no cc required).

Try it out: https://lnkd.in/gFsA9Cus

Have you tried the Kilo Code VS Code extension yet?

Thanks to Kilo Code for collaborating with me on this post.

--
💾 Save for later. Repost to help others.
🙋🏻‍♀️ Follow Nikki Siapno, turn on notifications.

If I had to choose a database for AI agents,
here’s what I’d consider:

Developers love Postgres (myself included).

But AI is changing what we require from databases.

They now need to handle time, meaning, and memory. 
All in one place.

Traditional systems weren’t built for that.

They struggle when faced with:

• Agent memory and context persistence
• Time-series data at massive scale
• Vector search and embeddings
• Semantic and hybrid retrieval
• Real-time event tracking

Each of these pushes traditional database architectures past their limits.

And stitching together ‘AI-ready’ add-ons or multiple specialized databases only adds complexity.

Agentic Postgres by Tiger Data brings time, meaning, and memory together.

It combines vector embeddings, hybrid search, MCP integration, time-series analytics, and observability in a single engine.

It’s Postgres, reimagined for the AI era.

There’s a Free Tier (no credit card required).

Try it out (for free): https://lnkd.in/g5Sy2qWW

What’s the first capability you’d prioritize in a database for AI agents?

Thanks to Tiger Data (creators of TimescaleDB) for building this innovative solution and partnering on this post.

--
🔖 Save for later • ♻️ Repost to help others learn
🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

taplio

Nikki Siapno's Linkedin Analytics

Nikki Siapno

Performance ScoreNikki Siapno's LinkedIn Performance

What is Nikki talking about?

Nikki Siapno's Best Posts (last 30 days)

Ready to grow your LinkedIn presence?

taplio

.css-6ytdur{background-image:linear-gradient(284deg, rgba(39, 43, 72, 1) 0%, rgba(33, 47, 183, 1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Nikki Siapno's Linkedin Analytics

Nikki Siapno

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);}Nikki Siapno's LinkedIn Performance

What is Nikki talking about?

Nikki Siapno's Best Posts .css-1emoo84{font-size:var(--chakra-fontSizes-md);font-weight:400;color:var(--chakra-colors-gray-600);}(last 30 days)

Ready to grow your LinkedIn presence?

Nikki Siapno's Linkedin Analytics

Performance ScoreNikki Siapno's LinkedIn Performance

Nikki Siapno's Best Posts (last 30 days)