Temporal Reviews

We use the product in our environment to manage a complex data pipeline for our highly data-intensive virtual operating system. Our system processes continuous data flows from instruments worldwide that collect stratospheric weather data. This data undergoes multiple conversions through several layers to reach an L2 format. 

The platform has significantly improved our organization's handling of complex and long-running workflows. It has enhanced our distributed systems' resilience and fault tolerance, especially considering our extensive use of load balancers, API gateways, and complex server configurations. It ensures that if something goes wrong, it is handled in a way that minimizes harm.

The solution's most valuable features include its ability to simplify the management of complex workflows, improve system resilience and fault tolerance, and reduce the need for extensive boilerplate code. 

One area for the product improvement is the learning curve. It can be challenging for new users, particularly those unfamiliar with the concept of workflow as code or data-centric applications. The complexity of managing the pipeline introduces some operational overhead, which requires more communication and coordination within the team.

I have been using Temporal for approximately nine months.

The solution is highly stable, particularly in maintaining resilience and fault tolerance across distributed systems.

I have had positive experiences with Temporal's support, particularly through their Slack workspace, where original developers are highly responsive and engaged in user support. They typically respond within a minute and remain involved until the issue is resolved.

Previously, we used tools like Airflow and DAXTER. We switched to Temporal because it offers superior fault tolerance and robust techniques for handling complex workflows.

The setup complexity is context-dependent. For our proprietary system, we integrated Temporal, which required managing multiple integration points, such as Docker servers, endpoints, distributed databases, and configuration management systems like NGINX or Caddy. While the installation was straightforward, the testing process was more complex due to using workflows as daemon processes.

The implementation was done in-house. 

For those new to workflow orchestration tools, start with simpler tools like Airflow before transitioning to Temporal. 

Temporal is better suited for users with a solid concept understanding and a well-developed intuition for complex systems.

It was chosen for its robust techniques in handling such complex workflows. We operate it on-premises using dedicated servers, and our customized scripts manage it.

I rate it a ten out of ten. 

Temporal serves as an orchestration manager for our Mac platform. It allows us to view and manage all the workflows within the application, providing a framework for implementing these workflows efficiently. Temporal itself doesn't store data; our AWS setup handles storage and other functionalities. Temporal offers a platform for orchestration management and provides SDK tools.

Temporal serves as an Orchestration Manager for our microservices architecture. It automates the communication and actions between multiple microservices. With Temporal, we can track workflows' progress, identify failures, and retry actions as needed. It eliminates the need for each microservice. Previously, we had a dedicated microservice for orchestration, but Temporal replaced it seamlessly.

Temporal provides visibility into workflow progress and analytics andsupports scheduled tasks with customizable settings, making it very convenient.

There are areas where Temporal could improve. For instance, calling multiple microservices with Temporal introduces latency due to workflow registration and analytics overhead.

I have been using Temporal for the past year.

I haven't experienced any stability issues or bugs with Temporal. It has been stable and reliable throughout my use, up to version 1.5.

I once contacted Temporal's support team regarding a certificate issue, but it was our mistake. Overall, I was satisfied with the support.

The initial installation and setup of Temporal was straightforward. We needed to generate a certificate and private key, making the process very simple.

If someone asked me whether they should use Temporal for the first time, I'd say it depends on their customer base. If they have few customers, RabbitMQ might be a better choice. However, if they have many customers or an event-driven system, Temporal would be easier to manage and track. For a beginner joining our team, learning Temporal might initially have a moderatelearning curve, but once you get the hang of it, it becomes pretty easy to understand.

I would rate Temporal nine out of ten because it's the best workflow manager I've used.The one-point deduction is mainly for potential improvements and the latency issue that can sometimes occur.

We normally use Temporal to create pipelines and to move data from FTP servers to some accounts.

When some jobs take a lot of time and fail midway, the solution’s retry feature automatically causes them to retry. We can put to sleep long-running jobs that take a lot of time and then run them again after some time.

Temporal lacks many resources, like YouTube videos, which users can use to learn or refer to if they get stuck with the solution. Normally, if someone gets stuck with other products, they can see some videos on YouTube, get an idea, and implement it. Temporal is very new in the market, so it lacks such resources.

I have been using Temporal for six months.

Temporal is a stable product. The solution has many good functionalities, but its documentation is very limited, with fewer examples. There's something called Signal in Temporal, but I'm not able to implement it because there are no videos or proper examples given on how to implement it.

Installation is the best part of Temporal because it is very easy to install the solution.

Temporal is a free, open-source tool. You don't have to pay anything. You just have to install the software and run it. Unless you go for the cloud version, you don't have to pay anything. If you go for other ETL tools, like ADF, you have to pay some price even for basic things. Temporal can be used for some basic things. Temporal is an open-source tool, and you can write anything customizable in Python code.

The project I was working on was an AI project. We used to bring data from different sources using Temporal and put it into Elasticsearch. We would then take data from Elasticsearch, implement some AI logic on it, and insert it back into Elasticsearch. AI logic was implemented in Python codes, and our Temporal job was to do the calculations using Python codes and dump the data back into Elasticsearch.

I suggest not using Temporal if your product is vital because if you are stuck somewhere, you will hardly get any resources. You will have to spend a lot of time to find out some functionality. Temporal has very limited documentation. If we have some POCs that are not so vital, then we can use Temporal to check something.

I was able to do some basic things. However, you will find very little documentation or examples if you want to implement some big things. You must spend a lot of time understanding the functionality or connecting with the Temporal team to understand it.

It is easy for a beginner to learn to use the solution for the first time. A new user may take around 15 days to one month to understand workflows. I also took around one month to understand the tool and then try to implement it.

Overall, I rate the solution a seven out of ten.

We use Temporal in our company to create child components and complete workflows that are dependent on each other. We also use it for child workflows and employee task orientation.

The most valuable thing about Temporal is that we can create multiple and child workflows. We can segregate work as we want, which is good for work organization. It's also easy to maintain. We're trying to generate and fill PDF forms with custom data, including digital signatures. We call AWS and do all activities through Temporal, like calling and saving data in buckets. We do this because we have a lot of load, with multiple users requesting data. We have two types of users: admin and customer. The admin creates forms, and employees or customers fill them out. When admin gets a form, it's stored in Temporal.

We convert RSA files to PKCS format for integration and have configuration settings. Many libraries help integrate the tool, making it easy to implement in Java and Python.

One issue is that we don't have enough resources in the community to get answers when we face problems. We once had a cross-cluster persistence issue, which we solved using different keys. I think Temporal is good right now, but I'm part of the community and will let you know if I think of any improvements.

We use the cloud version of Temporal. They provide a key that we insert in our files to execute functionality. Our certificate expires in one year, which can cause issues in the product. It would be beneficial if the certificate expiry timeline could be extended to two or three years, as changing it every year is challenging.

 One issue is that workflows without an expiry time can run indefinitely, overloading the server. It would be helpful to have a default timeline that automatically deletes or removes workflows after a month.

I have been working with the product for a year. 

The tool doesn't have any performance issues. 

The solution's scalability is high. 

I haven't contacted support yet. 

Before Temporal, we tried to implement Kafka, but Temporal was better suited to our use cases. We evaluated Kafka but decided to go with Temporal.

The initial setup can be tough for beginners as it's not like simple coding languages. You must understand how functions work, including small things like run methods. I followed the personal document. Three to four people were involved in the deployment. Deployment locally can take one or two days, including all activity checks and finalizing components.

I rate the overall solution a nine out of ten. 

Our team's project is about a service that allows you to hit third-party APIs. Let's say we have multiple products at our company. They will want to hit some third-party APIs for document verification, for which we have some third-party vendors. Instead of them directly hitting their product, we act as a layer in between. They hit our APIs, and then we hit the vendors, ensuring that the response they get is generalized.

Different vendors might have different responses. We give a generic response so that it's easier for them to handle at their end. We have two different modes of operation, namely, sync and async APIs. Async APIs are where we mostly leverage Temporal because async workflows are prone to errors and are not that durable. That's where Temporal comes in. We use Temporal to ensure the durability and scalability of our product.

The solution's most valuable feature is its ability to retry from an interrupted state. I think this feature makes it more popular among developers, and we specifically use and leverage this feature the most in our project.

Temporal doesn't have built-in data storage to store the state of the ongoing execution. We have to configure separate RDS for state management and data storage. Temporal should consider having its own data store so that we don't have to integrate with a third-party data store app.

I have been using Temporal for a couple of months in my company's recent project.

We didn't face an incident where Temporal was down for any reason. The only issue we faced was that we had allocated less storage to the RDS, which Temporal was using to store all sorts of data. Since the storage was less and we had more data pushed, it broke down. However, that had nothing to do with the solution.

I rate the solution’s stability a nine out of ten.

Temporal is a scalable solution both in terms of integration and handling multiple requests. When I spin an activity in a workflow, Temporal can manage it pretty well and store the state of the ongoing code irrespective of how heavy that activity is. In case of a failure, it retries from the current state.

The major challenge we faced was durability. There are instances where an execution gets interrupted, or our service goes down for some reason. Since we mostly use Temporal to interact with third-party vendors, those vendors or endpoints would often be down.

We had to have our own custom retry mechanisms, which come with building Temporal. There was no way to ensure the execution could be durable. The best thing we could do was ask the product to hit that API again.

I would recommend the solution to other users. The main reason why Temporal was built was to have a defined state for microservices. For databases, if we do a transaction, we can be sure either it will succeed or fail. There won't be any state where it's somewhere in between that. Temporal does the same thing for microservices.

Many open-source applications have to implement their own custom logic to ensure things Temporal offers by using an API call to their service using gRPC. This custom logic is heavy, apart from the business logic itself.

Overall, I rate the solution a nine out of ten.

We use Temporal to manage workflows for a client project involving interactions with MongoDB. We needed a framework to manage workflows and set the correct order and timing. We chose Temporal over Azure Functions because it worked better for our needs.

What I like best about the tool is that it's easy to install, especially since it uses JavaScript. It's also easy to set up with Docker, and the documentation is easy to understand.

Configuring workflows can be improved —the solution could offer more options, but it's not a must-have.

I have been using the product for a year. 

I haven't experienced any stability issues or bugs with Temporal. Any problems I encountered were more related to our specific project than the tool itself.

I think Temporal's scalability is very high. While our current project hasn't required much scaling yet, I can see the benefits for future use. I'd rate its scalability as an eight out of ten, mainly because it was easy to implement with Docker. 

In my organization, at least three people used Temporal when I was involved in the project.

I haven't contacted the support. I can manage with the documentation. 

Before implementing Temporal, we struggled with Azure Functions, which was hard to understand and manage. Temporal made it clearer how the workflow would function from start to finish.

Temporal is open-source and free to use, which is great. We didn't have to pay for any premium features.

You need to know Node.js, Express, and Docker to use the tool effectively. Docker is particularly important for easy setup and image mounting.

Overall, I'd give the tool a solid an eight out of ten. It's easy to use and start up, making it simple to begin a project.

I would recommend Temporal to others. My advice would be to clearly understand Docker, as it goes hand-in-hand with using Temporal for setup and implementation. I'd also recommend reading the documentation about creating plugins for Temporal to understand how to build workflows for any project.

We used the solution for integrations. I worked for a company that did international freight integrations, and we had to integrate with a system called CargoWise to help our customers track their containers and shipments. We used Temporal workflows to pull in data and keep everything in sync.

The solution's most valuable feature is its ability to fix things quickly. Suppose there's a bug in the code and the workflow you created in Temporal breaks in production. If we lose that data, the system will be out of sync. With Temporal, you can create and push a patch to production so that the workflow will retry automatically, and you won't lose any data.

We previously faced issues with the solution's patch system. We had to create the patch and put a condition on the code to check if the workflow was patched or not. Then, we needed to push another change to get rid of that patch.

I used Temporal on my previous job for seven to eight months.

In our case, the solution's scalability was pretty good. We used the Temporal Cloud service. Temporal gives you the option to either host it yourself or pay for the service, and we paid for Temporal Cloud. We also had our workers running on Kubernetes. It was pretty good. We had to scale it up a few times, but it just worked fine.

I rate the solution’s scalability an eight out of ten.

We contacted the technical support team many times to ask questions and get help, and they were very good at responding.

Positive

The solution's initial setup was straightforward, but setting up the tokens on Temporal Cloud was difficult. You had to create this token, and they have docs on it. You can install a Docker container that will create a token for you, but it's not production-ready. We had a couple of issues getting that going. However, it was fine after we learned it.

Temporal is worth the money.

One of the reasons we wanted to change to Temporal was to cut costs because our AWS bill was really, really high. We migrated all of our integrations to use Temporal workflows. The savings weren't as big as we initially expected, but they were pretty great from a developer's perspective.

You need to be a software developer or a software engineer to use Temporal. Other than that, its documentation is pretty good. It is a pretty new product. We found it online when we first started working with it. When we thought it would fit our needs, we read the docs and started building the workflows, and it worked.

I would recommend the solution to other users because it's a really good tool. Temporal gets rid of the need to worry about a bunch of things. When coding, I felt like I could focus on the integration itself, and I didn't have to worry that much about making sure things didn't break.

Suppose you have an integration, and you're building it all by yourself. If something breaks in a microservice, the other microservice needs to be ready, and everything needs to be ready to support that error without losing any data. Using Temporal got rid of a lot of that complication.

Overall, I rate the solution a nine out of ten.

We use this solution to power an internal workflow engine we've developed. Currently, it's being used within our company to manage workloads running on the orchestration platform.

Temporal fault tolerance has been beneficial for our critical business operations. It handles scheduled tasks and failures effectively, automatically retrying processes in case of issues. Additionally, our workflows are managed smoothly, with our internal engine providing inputs toTemporal for task execution. As for AI-driven projects, we haven't utilized Temporal in this domain yet.

The most valuable feature is its ability to manage and automate workflows without manual intervention efficiently. This includes handling functions and activities and orchestrating various tasks seamlessly. Temporal's reliability and performance have been exceptional for us, even with thousands of workflows running daily on-premises.

Temporal could be improved by making it more user-friendly for beginners and non-technical staff, ensuring easier integration and usability across different use cases.

I have been using Temporal for the past year and a half.

In my experience, I haven't encountered any issues or bugs. Everything has been working smoothly.

It is very scalable. We can run thousands of workflows simultaneously without any issues, so scalability-wise, it's perfect.

The initial setup of Temporal is straightforward. It's similar to deploying other servers; you must adjust the resources if necessary. Overall, no special knowledge is required.

I would rate it an eight because while it's robust and scalable, once you're familiar with it, there's a learning curve for newcomers due to the complexities involved. Additionally, managing specific errors and concepts can be initially challenging. However, its scalability and open-source nature are significant advantages.