Redpanda Reviews

We use Redpanda mainly for three purposes. The first is the standard Kafka-like data ingestion pipeline where you get an event and want to distribute it into multiple applications, not just one. The second, which is our main use case, involves capturing video recording data. When you consider how many video cameras exist even in a single city or metro, the volume becomes substantial. We capture what happened at each second, but we do not directly push it into the database. Instead, we pass it through Redpanda to ensure that everything follows a certain shape. Sometimes the data is corrupted, incomplete, or missing information. For example, an amount cannot be arbitrary; it has to be a specific number. We perform all those cleanups in our code while flowing the data through Redpanda with schemas in place. The third use case is backpressure management. If you want water to do the dishes but receive a fire hose instead, we ensure that you get the right amount of quantity. We keep this very simple, and after a certain point, it becomes a day-to-day operation.

Redpanda can handle real-time financial data streams and support aggregations. For example, with stock data where each tick represents a price point per second—such as Apple stock being 252.3, then 258, then 247—you can create means, medians, and averages. All these calculations work perfectly as long as your functions are pure. You get all the data without making additional API calls or database calls, flow it through Redpanda or any Kafka instance, and perform all kinds of calculations very quickly. The database is generally the slower component. Every single time we found it was almost always the database that gets slower or the way we normalize data causing issues. Redpanda never gave us any problems. I remember RabbitMQ used to give us a lot of problems, but all those problems are gone with Redpanda.

The video example I shared involves webcams. If you consider webcams as IoT devices, we use them that way and it just works. It is not real-time in the strictest sense, but it is almost real-time, which is good enough for our case.

One thing I really appreciate about Redpanda is that it is simple and available to host yourself. You do not have to pay money upfront to Confluent or have API contracts. Unless you want very high availability, you can just host it on your own server by running the Docker container and Redpanda works. This is very good. The other valuable feature is that migrating from one version to another has almost always been a very smooth experience. With Kafka, you have to manage a thousand things. These two are big benefits in Redpanda. The third feature is that the UI is slick. I would not say it is one of the best UIs in the world, but it is much better than what Kafka or Confluent comes up with out of the box.

One area for improvement is providing more examples. For instance, Redpanda could be more useful as a sink where you get the data and can directly push to S3. While this is possible through the API, there are better and faster ways to do it. You can make a million API calls and accomplish the task in one and a half hours, but the same thing can be done in ten minutes through other methods. These faster approaches are not documented in obvious places. You have to find information scattered across various blogs. Redpanda should collect all the good blogs and best practices and put them in their documentation. This is more about knowledge management and making it easy for users to understand the product for complex use cases. For simple use cases, it is straightforward. We all use the basic pipe functionality. However, providing more examples would be useful. For example, integration with AWS and the AWS ecosystem would be cool.

We have been using Redpanda for at least the last four years.

Stability has been pretty good. I would rate it around eight or nine. Once in a while we restarted, but overall it is pretty stable.

On scalability, we always scaled vertically. When 16 GB of RAM was not enough, we went to 32 GB RAM, then 64 GB RAM. We never scaled horizontally by adding one machine, then two machines, then three machines, and so forth. We just have a three-machine setup because if one machine fails, there is a backup, but it is not to distribute the load. In a way, it just works. I would say the scalability is around eight, nine, or ten. However, I do not know how well it scales horizontally. They obviously make big claims, but I never tried it because we just scale vertically.

We previously evaluated Confluent and Kafka itself. I would not dare to go with Kafka because it requires way more orchestration than required. Confluent was good, and Redpanda was also good. However, Redpanda was an order of magnitude cheaper than Confluent, so we went with Redpanda.

The initial setup for Redpanda is very smooth. Compared to Kafka, which feels like it requires a lot of knobs and pieces, Redpanda feels like a thirty-minute setup. This was actually one of the reasons why we wanted something we could just use rather than master first and then use. We started using Redpanda and then mastered it along the way because our use case is to flow it through the pipes, and that is done beautifully with Redpanda.

We use Docker Swarm and deployed Redpanda on-premises.

The pricing for Redpanda is very good. I would rate it around nine.

We evaluated a couple of alternatives and liked three of them: Confluent, Redpanda, and others. However, Redpanda was simple and fast, so we went with Redpanda and it just works. Under the hood, it is just Kafka. They say that since it is written in C++ and Rust as a high-performance Kafka, it is fast. All the programming libraries we have are written for Kafka, and our Kafka is Redpanda. Since Redpanda provides compatibility with Kafka SDKs and APIs, we do not use Redpanda-specific SDKs or APIs. I cannot tell you how fast or slow Redpanda is compared to the original Kafka because the only Kafka instance I use is Redpanda. Redpanda is fast enough, but I cannot say that the original Kafka is slow because I never used the original Kafka.

In my opinion, I am not sure about features for decision-making processes because I do not even know what kind of features are there for that. We just use Redpanda as a pipe. My overall rating for Redpanda is eight and a half out of ten.

Redpanda serves two primary purposes for our organization. First, we use it as a drop-in replacement for Kafka. Second, we utilize it for streaming analytics.

We do not use Redpanda for IoT data streaming, though it has been quoted as suitable for that use case. IoT data streaming is actually a superset of our use cases. Recently, we have started using it for AI analytics as well.

The best features of Redpanda include its lightweight nature and low resource consumption. Because we migrated from Kafka to Redpanda, this is the main selling point for our organization.

Aside from its lightweight design, Redpanda is essentially a clone of Kafka with all the good features of Kafka. The only difference is in resource requirements. Kafka needs too many resources while Redpanda is a very good, lightweight, and very fast database.

We use Kafka API compatibility with Redpanda, which helps significantly with data migration. There is no need to migrate data because it works out of the box. As a streaming solution, we never migrate the data. We simply have a clean state and replace Kafka with Redpanda. In my case, there was no need to migrate.

Redpanda’s low latency data processing is excellent. We do not experience too much latency, and it works very well for our product architecture. It is exceeding our estimations. While designing the product, we design it for a certain throughput, and Redpanda always works at that throughput.

The metrics I use to evaluate effectiveness in any real-time applications are throughput. Every application has its own throughput requirements, and so far, Redpanda is good at achieving the targeted throughput for our applications.

In Redpanda, the areas that have room for improvement are in the clustering part. Setting up clustering initially is very easy. However, if you are removing a node and attaching another node, significant improvement is required. It is not as expected, and we have had a tough time adding and removing nodes.

Other solutions lack clustering support, but Redpanda has good clustering support, though it needs further improvements for smoother cluster operations.

Aside from clustering, Redpanda is good, but it is worth noting that it is built on top of a special architecture. It works directly at the Linux kernel level. Because of that, it needs better modern hardware with a better CPU, not just a normal CPU. A server-grade CPU is required. It also needs modern memory, at least DDR5. It is not good with very old computer memory. Disk type matters as well. It is very good at NVMe SSDs but not good with old spindle hard drives. If a customer has modern hardware, it works very well. If a customer has legacy hardware, it will not work as expected.

I have been using Redpanda for more than three years.

Regarding stability, Redpanda is good. I can rate it ten out of ten for stability.

Redpanda scales very well. I would rate it ten out of ten for scalability.

My thoughts on support for Redpanda are that it is nine out of ten.

When I compare Redpanda with other solutions, such as Confluent Kafka and Amazon, I find that overall Redpanda is good compared to any other option. Kafka is good, but it is too resource intensive. Redpanda is good and requires fewer resources.

I find that the deployment of Redpanda is easy. It takes just less than an hour to deploy Redpanda. Operations are a bit tough, but deployment is easy.

In terms of pricing, Redpanda is free. We do not have to pay anything. It is not open source, but it is free.

I would recommend this product to other users. Overall, I would rate Redpanda as very good and would give it a ten out of ten rating.

Our main use case for Redpanda is to send a large volume of messages and consume those messages, essentially processing them.

Redpanda is renowned for handling very high throughput. Redpanda, or Kafka, is able to process billions of messages.

Instead of using raw Kafka, Redpanda helps us manage Kafka at a production level, and it has a nice user interface so we can interact with any pending messages and processed messages.

Redpanda is developer-friendly, and we need to do much less configuration because Redpanda provides out-of-the-box configuration for us. It is not only a nice UI, but it also requires less configuration compared to a raw Kafka server. Redpanda is built on top of Kafka; their main architecture is Kafka only.

It has impacted us in a way that we need to do very little configuration, so we can quickly deploy Redpanda in stage, development, or production environments. We spend less time managing the raw Kafka server compared to Redpanda; Redpanda is less maintainable.

Using Redpanda, we do not need a separate team that specifically manages Kafka, so we have fewer employees needed, possibly one or two less employees, and time is also saved.

Redpanda can be improved by providing more local meetups or online meetups to increase awareness, as very few people know about it.

I think Redpanda is overall very good for us, and I am uncertain whether Redpanda can scale to very large companies as we are a medium-sized startup. However, if we consider an example of a very large company like Uber, I am not sure whether it would fit there.

I have been working in my current field for more than 3.5 years.

Redpanda is very stable. As per our use case, it is very good.

Overall, the customer service was very good, and the AWS team is also supporting us at any point.

Negative

From the initial stages, we have been using Redpanda. Kafka server is one alternative, and another alternative is privately hosted Kafka servers on other cloud services.

Our DevOps team has deployed Redpanda and manages it. I do not have any specific configuration or measurements.

Kafka server is one alternative, and another alternative is privately hosted Kafka servers on other cloud services.

I recommend reading the documentation as it is comprehensive, and their user interface is also good. If you are a small startup or a medium-level startup, you can use Redpanda instead of Kafka. I would rate this product an 8 out of 10.

I have worked with Redpanda for the past two to three months. Mainly in the tech industry or software industry, there's a huge rise of streaming data. 

Redpanda serves as a very reliable and fast message broker, which lets you build applications asynchronously. The major use case is for my project specifically, we're using it for a monitoring system that we're building.

I haven't worked on enterprise-grade applications. It's a project for academic research for the college.

The industry standard for this kind of platform is Kafka. Confluent Kafka has acquired it. Kafka is an open-source platform built by Apache. Confluent is the commercial version of it. 

The major improvement of Redpanda over Kafka is firstly, good documentation. Redpanda's documentation is very easily understandable, and they have a lot of examples. In addition to that, most of the setups include using another technology called Docker, which I am very familiar with. 

Setting up technologies using Docker is very convenient to me, and Redpanda has provided many templates for that. Redpanda has its own built-in metrics exporter, making it easier to monitor and check performance. 

What makes Redpanda superior is its performance since it's written in C++. C++ is pretty much the standard for high-performance applications.

Recently, for the documentation, they've built their own AI chatbot, which is focused on giving you answers based on their documentation. While using that, I did not find it to be very good. Maybe due to the fact that it's a first prototype and was very recently released. However, from a product perspective, I do not have any problems.

I have used Redpanda for the past two to three months.

I am definitely satisfied with the stability provided by Redpanda.

In the free version, it's still working with containers itself. They've provided the template for one and three nodes for horizontal scaling. 

For our project, we've set up five containers. The template is ready in the Dockerfile they provided. You just add the existing nodes and give them the respective configurations.

I have not escalated any questions to technical support.

Positive

The industry standard for this kind of platform is Kafka. Confluent Kafka has acquired it. Kafka is an open-source platform built by Apache. Confluent is the commercial version of it. I have worked with Kafka, so I pretty much know how it works. I found Redpanda's documentation and setup to be more straightforward.

Once I learned about this platform, I read about it a bit and then I looked at how they set it up on their systems. It's a simple straightforward Dockerfile. If you have Docker installed on your system, you can just spin it up quickly without any issues.

Redpanda is actually a commercial platform, but they do provide free versions as well. I've been working only with the free versions.

Anyone finishing their bachelor's degree in computer science engineering would have had some hands-on experience with Kafka and understand how it works. Shifting from Kafka to Redpanda would be very simple for them.

I'd rate the solution ten out of ten.

We handle high volumes of telemetry data and operate under stringent latency requirements, with our data pipeline demanding sub-second response times. Redpanda seamlessly integrates into our data plane, particularly as a message broker system, where performance is absolutely critical. Its low-latency capabilities and robust performance have been essential to meeting our operational demands

The cost savings have been significant. We were able to eliminate one MSK cluster, and still, the end-to-end lag hasn't been worse. The performance is superb, and the value we are getting for the money we pay is great. Additionally, peace of mind is also a significant benefit due to the high performance and fault tolerance.

The whole system itself is valuable. The cost and performance are the primary benefits. Redpanda is extremely fast, which I describe as Kafka on steroids.

When it comes to self-hosting, their documentation could be improved. At the time we were onboarded, we had to apply our logic. Updating the documentation and managing the automation file for customer users to self-host would be beneficial.

I have been using Redpanda for two years now.

Redpanda has been highly stable for our workloads. It utilizes the RAFT consensus algorithm, which ensures reliability by maintaining a quorum for data consistency and fault tolerance in cluster formation.

I would rate the scalability of Redpanda as very high, around nine out of ten. They support a feature called tiered storage to offload data to keep the systems running efficiently, which provides us with ample capacity.

They are really helpful. During our onboarding, they were very resourceful and knew what they were doing.

Positive

We previously used AWS MSK. We switched because MSK was very costly.

The initial setup of Redpanda was straightforward and rated an eight out of ten. The setup involved using an Ansible script to bootstrap the cluster, which took about 10-15 minutes per cluster.

The deployment was handled internally by one person with assistance from the provided Ansible script.

Apart from cost savings, the high performance and low latency provide peace of mind and operational efficiency.

Redpanda is very cost-effective and offers competitive pricing compared to other options in the market. While not the lowest, the pricing is reasonable considering the high performance and value it delivers.

We considered Confluent Cloud, but after reviewing our needs, Redpanda seemed like the perfect fit due to its superior performance and cost benefits. Given that, we decided to move forward without a formal evaluation of other options.

I would advise users to consider their in-house technical expertise when deciding the deployment model for Redpanda. If there is a lack of expertise, it is better to opt for the managed service offered by Redpanda.

The main use case is a message stream. Just to process the data with window processing.

Operationally, it is good.

Two projects use artificial intelligence in combination with Redpanda right now.

The best thing is that it takes less resources compared to Kafka. We have a bad experience with Kafka; we need to restart the services because it's built on Java and requires a huge space on servers. 

Redpanda is based on C++ and is native to the operating system. Basically, it is memory efficient. We like it.

It's easy to learn to use Redpanda for the first time because it supports the Kafka client as a developer. It supports native Kafka clients. 

And from the operations perspective, it's a pretty standard installation. The online community support is also available.

The command-line tools need to be improved. To quickly check the status of the topics and all. 

For example, if I wanted to check how many messages are in a topic, there is a command, but we need to use different tools to get that information. It's not really built into the native tool.

I have been using it for three years. I use version 25.3.3 

I never experienced any bugs. So far, so good.

I tested it with ten-plus nodes, and it's highly scalable.

We are about 55 people, 12 people actively use it, and we use it for six products.

I never needed to contact the customer service and support because it's working as expected.

Positive

We opted for Kafka for two reasons. 

• One is we used to use Kafka, and we had to restart Kafka every quarter or so due to memory issues. 
• Compared to Kafka, Redpanda is stable and resource consumption is also very effective. It takes less resources compared to other tools.

It's very easy. The cluster setup is also very easy in Redpanda compared to others.

NO

Yes.

It's free. Everybody can use it, only support is paid.

We evaluated three: Kafka, Redpanda, and ActiveMQ.

I would recommend Redpanda to others because it's easy to set up, consumes less resources, and is stable compared to other tools.

Overall, I would rate it an eight out of ten because there is room for improvement. So far, it's nothing but a rewrite of Kafka. It needs improvement on some of the command-line tools. And the second thing is it doesn't have a management graphical user interface. That also needs improvement.