diff --git a/work/synadia_prep.md b/work/synadia_prep.md
index cdddd79..65f35ac 100644
--- a/work/synadia_prep.md
+++ b/work/synadia_prep.md
@@ -1,3 +1,84 @@
+Apache Kafka and NATS are both messaging systems, but they have distinct features and functionalities designed to meet different use cases. Here's a detailed comparison:
+
+### Apache Kafka
+
+**Overview**:
+- **Kafka** is a distributed event streaming platform capable of handling high-throughput, fault-tolerant, and durable messaging. It is designed for stream processing, real-time analytics, and integrating large data flows.
+
+**Features**:
+- **Durability**: Kafka persists messages to disk, ensuring data durability and reliability.
+- **High Throughput**: Capable of handling millions of messages per second due to its efficient data storage and retrieval.
+- **Scalability**: Kafka can scale horizontally by adding more brokers and partitions.
+- **Replication**: Data is replicated across multiple brokers to ensure fault tolerance.
+- **Stream Processing**: Integrates with Kafka Streams and ksqlDB for real-time data processing and analytics.
+- **Advanced Consumers**: Supports complex consumer groups for parallel processing.
+- **Topic-Based**: Organizes messages into topics which can have multiple partitions.
+
+**Typical Use Cases**:
+- Log aggregation
+- Real-time analytics
+- Event sourcing
+- Data integration across systems
+- Monitoring and alerting
+
+### NATS
+
+**Overview**:
+- **NATS** is a simple, high-performance messaging system designed for lightweight, cloud-native applications. It focuses on low latency, simplicity, and ease of use.
+
+**Features**:
+- **Low Latency**: Designed for fast message delivery with minimal latency.
+- **Simplicity**: Easy to deploy and manage, with minimal configuration required.
+- **Scalability**: Can scale to handle large numbers of connections and messages.
+- **Lightweight**: Consumes minimal resources, making it suitable for IoT and microservices architectures.
+- **Clustering and Federation**: Supports clustering for scalability and fault tolerance.
+- **JetStream**: Provides persistence, message replay, and at-least-once delivery guarantees.
+- **Flexible Delivery**: Supports both point-to-point and publish-subscribe messaging patterns.
+
+**Typical Use Cases**:
+- Microservices communication
+- IoT data collection
+- Real-time messaging
+- Distributed systems requiring low latency
+
+### Comparison
+
+| Feature/Aspect       | Apache Kafka                          | NATS                                      |
+|----------------------|---------------------------------------|-------------------------------------------|
+| **Durability**       | High (persists to disk)               | Medium (with JetStream for persistence)   |
+| **Throughput**       | Very high                             | High                                      |
+| **Latency**          | Medium to low                         | Very low                                  |
+| **Scalability**      | High (scales horizontally)            | High (clustering and federation)          |
+| **Complexity**       | Higher (more configuration and setup) | Lower (simple and easy to deploy)         |
+| **Message Model**    | Topic-based                           | Subject-based                             |
+| **Stream Processing**| Built-in (Kafka Streams, ksqlDB)      | Basic (with JetStream for simple cases)   |
+| **Replication**      | Yes (automatic)                       | Yes (with clustering)                     |
+| **Ordering**         | Guaranteed within a partition         | Best-effort (JetStream for strict ordering)|
+| **Consumer Model**   | Complex (consumer groups)             | Simple (point-to-point and pub-sub)       |
+| **Persistence**      | Built-in                              | Optional (with JetStream)                 |
+| **Deployment**       | More complex                          | Simple, lightweight                       |
+| **Typical Use Cases**| Big data, analytics, event sourcing   | Microservices, IoT, real-time messaging   |
+
+### Choosing Between Kafka and NATS
+
+- **Use Kafka if**:
+  - You need high durability and fault tolerance.
+  - You are dealing with very high throughput data streams.
+  - Your use case involves complex stream processing and real-time analytics.
+  - You require robust support for distributed data integration.
+
+- **Use NATS if**:
+  - You need low latency messaging.
+  - You prefer simplicity and ease of deployment.
+  - Your application is lightweight, such as microservices or IoT devices.
+  - You need a messaging system that scales easily with minimal overhead.
+
+### Summary
+
+While both Apache Kafka and NATS are powerful messaging systems, they cater to different needs. Kafka is well-suited for high-throughput, durable messaging and stream processing, while NATS excels in low-latency, lightweight messaging scenarios. Understanding your specific requirements will help you choose the right tool for your use case.
+
+---
+
 # NATS Technical Reference Guide for IoT and Smart Cities
 
 ## 1. Introduction to NATS