A dedicated state management platform for microservices gives us the same kind of abstraction that we see in atomic database transactions.

Microservices were meant to be a blessing, but for many, they’re a burden. Some developers have even moved away from them after negative experiences. Operational complexity becomes a headache for this distributed, granular software model in production. Is it possible to solve microservices’ problems while retaining their advantages?

Microservices shorten development cycles. Changing a monolithic code base is a complex affair that risks unexpected ramifications. It’s like unraveling a sweater so that you can change its design. Breaking that monolith down into lots of smaller services managed by [two-pizza teams](https://www.theguardian.com/technology/2018/apr/24/the-two-pizza-rule-and-the-secret-of-amazons-success?utm_source=thenewstack&utm_medium=website&utm_content=inline-mention&utm_campaign=platform) can make software easier to develop, update, and fix. It’s what helped Amazon grow from a small e-commerce outfit to the beast it is today.

Microservices also introduce new challenges. Their distributed nature exposes developers to complex state management issues.

# The Yoda Principle
Ideally, developers shouldn’t deal with state management at all. Instead, the platform should handle it as a core abstraction. Database transaction management is a good example; many database platforms support atomic transactions, which divide a single transaction into a set of smaller operations and ensure that either all of them happen or none of them do. To achieve this behavior, the database uses transaction isolation, which restricts the visibility of each operation in a transaction until the entire transaction completes. If an operation fails, the application using the database sees only the pre-transaction state, as though none of the operations happened.

This transactionality enables the developer to concentrate on their business logic while the database platform handles the underlying state. A database transaction doesn’t fail half complete and then leave the developer to sort out what happened. An account won’t be debited without the corresponding party’s account being credited, for example. As Yoda said: “Do or do not. There is no try.” Appreciate ACIDSQL databases, he would have.

“Phew,” you think. “Thank goodness I don’t have to write code to unravel half-completed operations just to work out the transaction state.” Unfortunately, microservices developers are still living in that era. This is why Yoda never used Kubernetes.

# I’ve Got a Bad Feeling about This

In microservice architectures, a single business process interacts with multiple services, each of which operates and fails autonomously. There is no single monolithic engine to manage and maintain state in the event of a failure.

This lack of transactionality between independent services leaves developers holding the bag. Instead of just focusing on their own applications’ functionality, they must also handle application resilience by managing what happens when things go wrong. What was once abstracted is now their problem.

In practice, things can go wrong quickly in microservice architectures, with cascading failures that cause performance and reliability problems. For example, a service that one development team updates with new error types can cause other services to fail if they haven’t also been updated to handle those new errors.

The brittle complexity of microservices is a challenge, in part because of the [weakest link effect](https://www.sciencedirect.com/topics/materials-science/weak-link?utm_source=thenewstack&utm_medium=website&utm_content=inline-mention&utm_campaign=platform#:~:text=The%20%E2%80%9Cweakest%20link%20hypothesis%E2%80%9D%20implies,application%20of%20a%20specific%20load.). An application’s overall reliability is only as good as its least reliable microservice. The whole thing becomes a lot harder with asynchronous primitives. State management is more difficult if a microservice’s response time is uncertain.

# Look at the Size of That Thing

Another aspect of this problem is that managing state on your own doesn’t scale well. The more microservices a user has, the more time-consuming managing their state becomes. Companies often have thousands of microservices in production, outnumbering their developers. This is what we noticed as early developers at Uber. Uber had 4,000 microservices, even back in 2018. In this environment, we spent most of our time writing code to manage the microservice state.

Developers have taken several approaches to solve homegrown state management. Some use Kafka event streams hidden behind an API to queue microservice-based messages, but the lack of diagnostics makes root cause analysis a nightmare. Others use databases and timers to keep track of the system state.

Monitoring and tracing can help, but only up to a point. Monitoring tools oversee platform services and infrastructure health while tracing makes it easier to troubleshoot bottlenecks and unexpected anomalies. There are many on offer. For example, Prometheus offers open-source monitoring that developers can query, while its sibling Grafana adds visualization capabilities to trace system behavior.

These solutions can be useful, providing at least some observability into microservices-based systems. However, monitoring tools don’t help with the task of state management, leaving that burden with the developer. That’s why developers spend way too much time writing state management code instead of highly differentiated business logic. In an ideal world, something else would abstract state management for them.

# Use the Microservices State Management Platform, Luke

The answer to simplifying state management in microservices is to offer it as a core abstraction for distributed systems.

We worked on a statement management platform after spending far too much time manually managing microservices state at Uber. We wanted a product that would enable us to define workflows that make calls to different microservices (in the language of the developer’s choosing), and then execute them without worrying about it afterwards.

In our solution, which we originally called Cadence, a workflow (a function that defines your high-level business logic in code) automatically maintains state while waiting for potentially long-running microservices to respond. Its concurrent nature also enables the workflow to continue with other non-dependent operations in the meantime.

The system manages disruption in state without requiring developer intervention. For example, in the event of a hardware failure, the state management platform will continue running a Workflow on another machine in the same state without the developer needing to do anything.

# Do. Don’t Not Do.

A dedicated state management platform for microservices gives us the same kind of abstraction that we see in atomic database transactions. Developers can be certain that a Workflow will run once, to completion. Temporal takes care of any failures and restarts under the hood. Now, microservices-based applications can guarantee that a debit from one account will always credit the other in just a couple of lines of code. Developers get the best of both worlds: the shorter development cycles of microservices with the exactly once execution of database transactions.

This fixes a long-standing problem with microservices and supercharges developer productivity, especially now that they are typically responsible for the operation of their application in addition to the development. Finally, developers that want the benefits of microservices can enjoy them without having to go to the dark side.


social-yoda

Do...Or Do Not: Why Yoda Doesn't Use Microservices

CTO and Co-Founder

Samar Abbas

samar abbas

Do... Or Do Not: Why Yoda Doesn't Use Microservices

We are pleased to announce that Temporal Cloud is no longer designated "developer preview" and is now in "expanded access!"

Temporal Cloud opened to developer preview in 2021, and during the course of the past year we have onboarded more than 100 organizations to the service.  A sincere thank you to all the members of the community that joined the preview from the earliest days.  Thanks to this collaboration, Temporal Cloud is the simplest, most reliable and affordable way to incorporate durable execution to software services & applications.

What is "expanded access" and why don't we just say GA?

Most importantly, "expanded access" means *no more waitlist*.  We have taken down the waitlist signup and replaced it with [a simple form to sign up for Temporal Cloud](https://pages.temporal.io/cloud-request-access.html).  If you're working for a company that wants to use Temporal Cloud and you are comfortable with our regions, pricing, and terms of service, we'll onboard you to the service within a week.

Our experience powering Temporal workloads large and small, in development and in production, and our recently added self-service features give us the confidence we can keep up with the interest in the service.  We added as many customers in the past 6 weeks as we have in the previous 18 months.  We’re happy with the user feedback and service performance so far.

Temporal Cloud will become fully generally available when there is no time lag between signup and onboarding, when we can offer accounts to users as well as companies, and when we can offer access to organizations that opt to decline production support (currently we require this).  Meanwhile, [Temporal Cloud is available for production workloads from 0.1 - 100,000+ actions per second in 7 regions](https://temporal.io/cloud).

We have an exciting roadmap planned for Temporal Cloud.  We plan to make ever greater advances in:

- Simplifying the experience of adopting and productionalizing Temporal with better automation and self-service features
- Continuing to lower the total cost of running Temporal services and applications
- Further expanding the “operational envelope” of Temporal Cloud namespaces; improving the upper limits and the uniformity of our throughput, scaling, uptime, and latency
- Adding to the set of features that cater to enterprise needs around operations, security, business continuity, and platform teams.

To keep abreast of the latest updates to Temporal Cloud, please join our [monthly newsletter](https://pages.temporal.io/newsletter-subscribe) where you’ll learn about this and other improvements we are making to the Temporal open source platform and to resources we provide to the developer community.

Thanks again for your support of the Temporal open source project and our company.

social-sphere

We are pleased to announce that Temporal Cloud is no longer designated "developer preview" and is now in "expanded access!"

Temporal Cloud is Now Expanded Access

Charles Zedlewski

charles zedlewski

*This blog post is a public copy of our monthly newsletter sent on October 18. If you'd like to receive upcoming updates by email, you can [subscribe to our newsletter here](https://pages.temporal.io/newsletter-subscribe "Subscribe to the Temporal newsletter").*  

We had a great time at GopherCon and loved getting the chance to know everyone who was able to stop by our happy hour! Read more in our post [Temporal @ GopherCon2022](https://temporal.io/blog/temporal-gophercon-2022).

If you weren’t able to be in Chicago with us or just can’t get enough of Go, we’ve got you covered! On October 26, Tom Wheeler, our Principal Curriculum Developer, is hosting a [workshop](https://pages.temporal.io/workshop-go-10-26) about developing applications using Temporal and Go. No matter your experience level with Temporal, you won't want to miss it!

Are you still missing the workshops from Replay? Check out Tom’s new [Temporal 101 course](https://temporal.io/blog/self-paced-temporal-101-training)! It’s a free, self-paced course available now to learn Temporal anywhere and anytime.

To learn more about what’s been going on with Temporal, check out our updates below!

Also, if you haven't joined already, we’d love to hear from you! Share feedback in our [Community Slack group](https://temporal.io/slack), or on Twitter ([@temporalio](https://twitter.com/temporalio)).

## Cloud
We have announced the public beta of the Temporal Cloud UI at [cloud.temporal.io](http://cloud.temporal.io). Users with a Temporal Cloud account can now access our latest Cloud UI and self-service features. More information can be found [here](https://docs.temporal.io/cloud/release-notes/release-note-2022-09-21).

[How to connect to Temporal Cloud](https://docs.temporal.io/cloud/how-to-get-started-with-temporal-cloud#connect-to-temporal-cloud) and other Clusters has been updated in the Cloud docs and [Dev guide](https://docs.temporal.io/application-development/foundations#connect-to-a-cluster). This provides clear, usable examples for connecting your Temporal Clients to the Temporal Cloud.

## Technology
__Python test framework new CDN:__ The Python SDK is nearing GA availability with some serious momentum behind it. We did notice that pulling down the test framework from the previous host didn’t have that same momentum. To resolve this issue, we’re now using a new content delivery network (CDN) to download the time skipping test server and [Temporalite](https://github.com/temporalio/temporalite). This functionality is also available in TypeScript.

__Encrypt the things!:__ Data Converter is a cornerstone of Temporal, which provides immense security value to Workflow providers and consumers. While Data Converter is fairly comprehensive, there are some specific areas that don’t go through the encryption path (for example, errors and stack traces). In our continued effort to bring comprehensive support to Data Converter, the latest releases of Temporal's TypeScript and Go SDKs now encrypt error messages and stack traces.

__Scheduled Actions Beta:__ A huge segment of users adopt Temporal for its durable Cron capabilities. While the Temporal Cron has always been powerful and reliable, the user experience has been historically… rough. The breadth of features also leaves a lot to be asked for. [Scheduled Actions](https://docs.temporal.io/workflows#schedule) takes the great parts of our original Cron functionality but with an entirely reimagined user experience and feature set. Schedule Actions is now in Beta and turned on by default with Temporal Server v1.18. We doubt you’ll ever use another Cron tool again.

__Batch operation API:__ Manipulating individual Temporal resources is easy enough, but when it comes to thousands or millions of resources, life isn’t so easy. There has always a bit of irony here, considering Temporal is a system designed around hyperscale Workloads. In v1.18 of Temporal Server, we’ve turned on the Batch operation API by default. We still have some improvements to make in this problem space, but the Batch API is a huge step in the right direction.

__Added support for ElasticSearch 8, deprecated ElasticSearch 6:__ Just keeping up with the latest and greatest for our dependencies. Our wonderful technical writing team [recently released a guide covering the migration process of ES6 -> ES7](https://docs.temporal.io/kb/migrate-visibility-data-from-es6).

__Removed 30 day max retention limit:__ Historically, it has been impossible to configure a Namespace retention policy greater than 30 days. Believe it or not, this was not an arbitrary limit as much an implication of legacy architecture design choices. We are beholden to the past no longer, and after some refactoring this limit has been officially removed!

__Timers section to app dev guide:__ We've added a [Timers section](https://docs.temporal.io/application-development/features#timers) to the Application development guide, which shows how to sleep inside of Workflow code.

__Side effects section to app dev guide:__ A [Side Effects section](https://docs.temporal.io/application-development/features/#side-effects) has been added to the Application development guide. The section shows how to implement a Side Effect in your Workflow code. Currently Go and Java are represented.

__History Shard docs page:__ We’ve added a page documenting the History Shard concept in the [Clusters core concept guide](https://docs.temporal.io/clusters#history-shard). It explains what a History Shard does and how it works, providing a foundation for the discussion around choosing the optimal number of History Shards for your use case.

__Cluster metrics reference:__ This is not a complete list of metrics that are emitted by the Cluster, but represents many of the most commonly used ones. We will continuously expand on this moving forward.

#### Meet the team:
![meet the team-technology](//images.ctfassets.net/0uuz8ydxyd9p/7KdkugaY0IBP1jlnXWxmQu/df110b02810443c067b239215a10ad0e/meet_the_team-technology.png)

## Content and community
__Temporal’s Flagship Community Meetup:__ We gather as a community (virtually on Zoom) once a month to discuss use cases, upcoming events, and the latest releases and features. Register through the following link, [temporal.io/meetup](https://temporal.io/meetup).

__Dominik @ Strange Loop:__ Our own Dominik Tornow recently presented a compelling argument about [Workflows as a new abstraction for distributed systems](https://twitter.com/strangeloop_stl/status/1580585976715677697) at Strange Loop 2022. The talk was a huge hit with the crowd and deeply examines the requirements of building reliable applications in our modern Cloud world.

__GopherCon and GopherPizza! demo:__ In addition to StrangeLoop 2022, our team also made it out to this year's GopherCon. Fitz, one of our amazing advocates, gave a lightning talk about Temporal, which generated quite a bit of buzz. We also had a booth where we demoed an application, also written by Fitz, called [GopherPizza!](https://github.com/afitz0/gophercon2022-temporal-demo)

__Upcoming DashCon:__ As you may already know, we’re pretty fond of our partners over at Datadog. That’s why we were beyond excited when the Datadog team approach our own Rain Leander about participating in a panel at this year's DashCon. The topic of the panel is "[What Users Really Want](https://www.dashcon.io/talks/what-users-really-want)" which dives into the best ways of understanding how users are truly experiencing your product and methods to improve their engagement.
#### Meet the team:
![meet the team-content community](//images.ctfassets.net/0uuz8ydxyd9p/3k0hUsj8497GebMEum9xd0/2308f3560cafc94186614667f8e30bae/meet_the_team-content_community.png)
## Community Spotlight
#### Twitter thread of the month
Check out [@DominikTornow](https://twitter.com/dominiktornow?s=21&amp;t=LTZehYSyvtSBRR8vIkM2Tw)'s Twitter page for a thread on recovery in the face of failure. Also, see his talk from Strange Loop 2022, where he discusses "[Workflows, a new abstraction for distributed systems](https://www.youtube.com/watch?v=V_5WeVmyhzg)".
![dominik-twitter-thread-recovery-failures](//images.ctfassets.net/0uuz8ydxyd9p/78SJFkA1SfjirVcSA8fnMf/859f72f32998dfabf651b2250c2eb4d8/dominik-twitter-thread-recovery-failures.png)

social-orb

We had a great time at GopherCon 2022 and loved getting the chance to know everyone who was able to stop by our happy hour! Be on the lookout for more about our time at GopherCon 2022 in the near future.

Temporal Community Newsletter: October 2022

![GopherCon2022](//images.ctfassets.net/0uuz8ydxyd9p/2DXHFx6fn4wmBApDY21UTt/5caf4a8c96457b24f87edc33697371d6/GopherCon2022.png)

## When Gophers Meet Dinosaurs
A weekend or two ago, we attended GopherCon in Chicago! It was exciting, fun, and illuminating to talk to so many Go developers. We got so many opportunities to learn about what people are working on and what they find interesting, and also hear their thoughts on Temporal.

Go is one of the more popular languages to use with Temporal, which makes GopherCon a natural place for us to show up. And, whether any given Gopher has heard of Temporal or not, shared experiences — like seeing seas of if err != nil in your nightmares dreams — make conversations go smoothly.
![fitz-presentation](//images.ctfassets.net/0uuz8ydxyd9p/4TOd25MIyPqFE07WxxkYbY/b03f99c31bdc139fb6cae123f3af994a/fitz-presentation.jpeg)

Case in point: on Day 2, I did a 7-minute lightning talk about Temporal, building up from a skeleton of a program and progressively adding more and more error checking. At the point my less-than-10-line function had turned into a 200-line program (rendered in 2pt font), the uncomfortable chuckles emanating throughout the room told me we were on the right track. As a member of the audience told me afterwards, "You walked through the exact story that we've painfully gone through so many times."

And it’s a story we talked through every time we spoke to anyone at the conference, with questions like:
* How do you handle failures in the application?
* If a node in your pool dies and Kubernetes brings a new one up, that’s great, but what happens with the application that was running on the now-deceased node?
* How do you manage processes, API calls, tasks that potentially take a long time, longer than the expected lifespan of a single node?

Inevitably, queues, databases, pollers, timers, event sourcing, event streaming, key/value stores, and other patterns and architectures enter the conversation. Software engineering as a field has developed strategies and patterns for handling these situations, all in an effort to mitigate the effects of [the fallacies of distributed systems.](https://en.wikipedia.org/wiki/Fallacies_of_distributed_computing)

Most of us would scoff at being asked to implement in-memory quick sort in an established language, so why should we all continually have to reimplement 200 line programs for a simple 3-step process?

That is the story I told on stage, leading right into a demo of a Temporal application. Think about a backend service you’ve written before, something that has the potential to take a while. If you kill it and restart it, what happens? With Temporal, we did this live in front of all of GopherCon: start a workflow, kill the worker after a few seconds, modify the code, and restart the worker. If you know Temporal, you know what happened next.

## When Dinosaurs Meet Gophers
We didn’t just blabber on at people though. We let others do a bit of talking, too! 😉

Learning about people’s use cases, applications, and current best practices (whether they’re followed or desire to be followed) was probably one of the best parts about the conference.

Lots of Gophers care about error handling, failure mitigation, and building interesting systems for these things. What they’re doing it for is all over the place. Banking and finance, infrastructure management/provisioning, SaaS, observability, eCommerce, OS-level high-availability, business operations, logistics & shipping, media, consumer electronics, real estate, and more.

Brainstorming with Gophers about whether and how their use-case could fit into Temporal was enlightening and exciting!

![Fitz-demo](//images.ctfassets.net/0uuz8ydxyd9p/7AI6IOa1NXrkPKG9d6W8QP/d127397b764d382ca99995049e161f34/Fitz-demo.jpeg)
![Kevin-talk](//images.ctfassets.net/0uuz8ydxyd9p/3NRUqKuhkxIX2f4eXolqD8/53b9725d1f7e476d4ee304095c26882f/Kevin-talk.jpeg)
![Fitz-talk](//images.ctfassets.net/0uuz8ydxyd9p/7bJEud5F6u2aMN9BBpnUql/7c1018ea1b65cfe9c24654268280052c/Fitz-talk.png)

Take SaaS for example. Imagine you were trying to build a “Webhooks as a Service” service. How would you do that?

I had a great conversation on exactly this question. If we tried to imagine this being backed by a Temporal Workflow, how would it factor in? Does it manage the infrastructure, the requests coming into a webhook, or some combination?

I can’t promise any answers, but I can promise more questions leading to deeper conversations.

See you at the next GopherCon, gophers!

And if you're interested in the source code from my talk, you can find it all in [this GitHub repo.](https://github.com/afitz0/gophercon22-lightning-talk)
![Gopher-Temporal](//images.ctfassets.net/0uuz8ydxyd9p/3gkeWhpH5TCUw13tqHIbHS/2a3e387af24668305180abbe6331f96c/Gopher-Temporal.png)


social-waves

A weekend or two ago, we attended GopherCon in Chicago! It was exciting, fun, and illuminating to talk to so many Go developers. We got so many opportunities to learn about what people are working on and what they find interesting.

Temporal @ GopherCon2022

Developer Advocate

Fitz

*This blog post is a public copy of our monthly newsletter sent on September 9. If you'd like to receive upcoming updates by email, you can [subscribe to our newsletter here](https://pages.temporal.io/newsletter-subscribe "Subscribe to the Temporal newsletter").*  

We're so happy to have met many of you at Replay, Temporal's inaugural developer experience conference, a few weeks ago. Replay had everything from live architecture reviews to Temporal 101 workshops, discussions about SDKs, cloud, and engineering, as well as talks from Datadog, Stripe, Square, and Yum! Brands.

If you weren't able to join Replay in person, don't despair! We're working on a series of regional events for 2023 (more details on that below). In the meantime, we've added session recordings from this year's event to [this playlist](https://www.youtube.com/playlist?list=PLl9kRkvFJrlRWBrfqOOX1rN_d1mahYI70) for you to view and share.

We've also arranged for you to get a sneak peek at Temporal Cloud later this month; don't miss [A Guided Tour of Temporal's New Web UI](https://pages.temporal.io/guided-tour-cloud-ui) on September 23.

For more information on what we've been working on, just keep reading! And as always, we'd love to hear from you—feel free to share feedback in our [Community Slack group](https://temporal.io/slack), or on Twitter ([@temporalio](https://twitter.com/temporalio)).

## Technology

**Batch operation API:** Batch operations make it easier to operate large scale systems. While Temporal has long supported some form of batch operations, we recognized the need for improvements. In V1.18, we've surfaced an explicit Batch Operation API which is supported at a namespace level and should make leveraging our batch capabilities much more straightforward.

**Multi-cursor queue:** This improves persistence resource utilization and provides better isolation between tenants. This update is coming in V1.18.

**Python SDK beta:** In the last newsletter, we announced that our Python SDK had reached the alpha milestone. Since then, we've made immense progress and are incredibly excited to announce that our Python SDK has reached the beta milestone. More than that, we are in the final stages of beta and already have our eyes on a GA release. If you haven't already started experimenting with the Python SDK, there's never been a better time.

**New default `tctl` experience:** `tctl` is one of the most critical tools for managing your Temporal Cluster and its resources. Historically, the user experience of `tctl` has left…well, something to be desired. That's why we are so excited for `tctl` v2, which provides a more powerful experience with far better UX. `tctl` v2 will become the default experience in Temporal Server version 1.18. Along with this release, we are also deprecating the original `tctl` as well as Web UI v1 on **September 30, 2022**.

**Auto-config for Spring Boot:** It's rare to be a Java developer in 2022 and not work with Spring Boot in some way. Although you could always manually configure Spring Boot with Temporal, the outcome is usually not ideal and leaves the hard work to users. With auto-config support, working with Spring Boot will become a first-class experience in Temporal.

**Spring Boot demos:** Spring Boot integration was recently added to Java SDK and the support team is working hard to have companion demos for that functionality. We also have plans for demos of the beta-stage schedules functionality that will be enabled in the next server release, version 1.18.

**Brand new documentation guides:** We are constantly on the lookout for gaps in our product adoption process that could be addressed exclusively by adding new content (eg: not developing anything new). We've found guides to be an excellent tool for covering multiple of these gaps at once. The team is actively working on a guide for [Getting started with Temporal Cloud](https://docs.temporal.io/cloud/how-to-get-started-with-temporal-cloud/ "Getting started with Temporal Cloud"), as well as guides for managing your [certificates](https://docs.temporal.io/cloud/how-to-manage-certificates-in-temporal-cloud/) and [namespaces](https://docs.temporal.io/cloud/how-to-manage-namespaces-in-temporal-cloud/) in Temporal Cloud.

**Knowledge Base added to our docs:** The new [Knowledge Base (KB) articles](https://docs.temporal.io/kb) section introduces a new information archetype to our existing documentation. The Knowledge Base goes beyond step-by-step instructions and explanations of key concepts, providing relevant details on a specific topic. For example, want to know the differences between Cadence and Temporal? We have an article for that!

## Content and Community

### Re-Replay (localized mini Temporal conferences)

Replay was so above and beyond our expectations that we want to do it again. And again. And again and again. So, yes, there will be a Replay next year, for sure, BUT! For those in other regions of the world or who couldn't make it to Seattle, we think a mini version might be just what the dinosaur ordered.

Can you imagine? A single day - with a live architecture review, a couple of BoF discussions, a customer talk or two highlighting experience and lessons learned and, you're invited.

To make it happen, jump on our [community Slack](https://temporal.io/slack) and send a DM to Rain, Temporal's newest Developer Advocate and actual live dinosaur. And we'll see you there.

**First self-serve Temporal course coming soon:** Our Education team is working hard to bring you our first self-paced course focusing on Temporal's fundamental building blocks, Workflows and Activities. The course will be available by October, but you can sign up now to be notified when the course goes live. Sign up now and we'll also let you know about other courses and learning opportunities in the future. [https://learn.temporal.io/courses](https://learn.temporal.io/courses/)

### We want YOU!

We'd love your help in making Temporal great. Please review our [contribution guide](https://github.com/temporalio/temporal/blob/master/CONTRIBUTING.md).

If you'd like to work on or propose a new feature, first peruse our [proposals repo](https://github.com/temporalio/proposals) to discover existing active and accepted proposals. Feel free to join the Temporal [community](https://community.temporal.io/) or [Slack channel](https://temporal.io/slack) to start a discussion or check if a feature has already been discussed. Once you're sure the proposal is not covered elsewhere, please follow our proposal instructions or submit your own feature request.

And, frankly, any time you participate in any way, you're contributing to this fantastic project and we cannot thank you enough.

Recent forum highlights include:

*   **[What are the recommended settings for workflow and activity pollers count?](https://community.temporal.io/t/what-are-the-recommended-settings-for-workflow-and-activity-pollers-count/5617)**
*   [What is really a workflow task?](https://community.temporal.io/t/what-exactly-is-a-workflow-task-and-how-often-are-they-scheduled/5801/4)
*   [General recommendations for building service using Temporal](https://community.temporal.io/t/build-temporal-microservice/5803)
*   [How to batch activity inputs?](https://community.temporal.io/t/action-batching/5773)

### Upcoming Events

- Sep 21: [Cloud Native Computing Luxembourg: Build fault tolerant, distributed Cloud applications with Kubernetes and Temporal](https://www.meetup.com/luxembourg-kubernetes-and-cncf-meetup/events/286995911/), Luxembourg, LU and Virtual
- Sep 22 - 24: [Strange Loop](https://www.thestrangeloop.com/2022/workflows-a-new-abstraction-for-distributed-systems.html), St. Louis, MO
- Sep 23: [A Guided Tour of Temporal's New Web UI](https://pages.temporal.io/guided-tour-cloud-ui), Virtual
- Oct 7 - 8: [Gophercon](https://www.gophercon.com/), Chicago, IL

## Community Spotlight

Alexandra Li from Convoy Tech is the author of this month's Community Spotlight.

[Intern Summer Spotlight: Temporal Replay through CircleCI ›](https://medium.com/convoy-tech/intern-summer-spotlight-temporal-replay-through-circleci-870d9246c2e8)

Alexandra wrote an outstanding post about integrating the Temporal Replay functionality with a CI/CD pipeline (CircleCI). This is a very common pattern for Temporal adopters, so having reference material from a real user is a huge improvement!

### Twitter thread of the month

[![](//images.ctfassets.net/0uuz8ydxyd9p/6n6W3fA9Um5uY7toa2qjEh/d46af96b17af49c8315b5fc5b58d0de9/dominik-tornow-academic-papers.png)](https://twitter.com/DominikTornow/status/1562974438739841024)

Check out [@DominikTornow](https://twitter.com/DominikTornow/status/1562974438739841024)'s favorite academic papers related to Temporal.

We're so happy to have met many of you at Replay, Temporal's inaugural developer experience conference, a few weeks ago.

Temporal Community Newsletter: September 2022

If you were in the Seattle area on August twenty-fifth and twenty-sixth and DID NOT come to Replay, I am so very sorry. *You missed an amazing event.*

Temporal hosted its inaugural developer experience conference, encompassing everything from in-depth discussions around SDKs and live architecture reviews to Temporal 101 workshops, talks from Datadog, Stripe, Yum!, and, yes, actual real living dinosaurs. *That last bit might be a slight exaggeration, but those who know, know.*

Our main goal in hosting a conference was to bring our Temporal community together, better understand everyone’s needs, share what we have been up to and where we are headed, and have some fun while we are at it.

![after-party](//images.ctfassets.net/0uuz8ydxyd9p/1mjzNyNjBQpnXjnV4SzhPR/b4d08a31cb3b91a35c402de324b569b3/after-party.jpeg)

While it’s hard to capture the epic nature of the conference in a blog post, we can give you the highlights and encourage you to DEFINITELY attend next year.

## Day One: Community Day - Workshops and Guided Discussions
It’s really important for us to understand how our customers are using our product, and encourage best practices along the way! For day one, we started with a series of hands-on ways to engage with us. This included architecture review, a 101 workshop, and in-depth conversations around our SDKs, and ended with a roadmap. We asked users and potential users to bring their own in-progress applications and services for an architecture review from Temporal experts.

![Application Architecture Review](//images.ctfassets.net/0uuz8ydxyd9p/68jLwYyWHkOt5kOh7159s0/36b9e9bbd97fccf90ec30cfb6a569d89/IMG_1277.jpg)

This day was special, because we know our community is pretty incredible, but we’re so impressed—not only did we have plenty of volunteers share projects throughout the day for review, engage in conversations, and partake in the workshop, but we had too many. Your energy and engagement was top notch and we are still carrying that with us today! We have many people to follow up with after for more conversations and reviews. Did we mention we love our community? *You all are doing some AMAZING things!*

We held four [Birds of a Feather](https://www.merriam-webster.com/dictionary/of%20a%20feather)-style discussions focused on Temporal SDKs, Server & Operations, Cloud, and Platform Engineering, hosted by Temporal team members. The Temporal representatives gave a high level overview to kick off the discussion and then talks were entirely led by people’s curiosities, questions, and comments.

![Birds of a Feather Cloud Replay 2022](//images.ctfassets.net/0uuz8ydxyd9p/6UBjVhgjxkXdyzv44mLFAV/bb2e15d94598f0b3c140d5dda49997cb/IMG_1283.jpg)

After lunch, the Temporal 101 Workshop started. This was intended for those super new to all things Temporal, and it covered the basic architecture, how to create and execute a Workflow, how to use the Web UI, and the value around Activities. Towards the end, Tom Wheeler, the workshop leader, walked line by line through the code from the exercises to show what happens behind the scenes to facilitate a stronger understanding of Temporal.

We have some exciting news for those who weren’t able to take it: we will have it available via an [online self-serve course](https://learn.temporal.io/courses/temporal_101) as soon as this fall!

To wrap up day one, we shared our first ever [Roadmap](http://t.mp/roadmap)! In true Temporal teamwork fashion, this was presented from an array of integral team members. We covered a lot, but at a high level:

- A single binary - new users will be able to get started by installing the package from popular package managers such as apt and brew (thx, Datadog!)
- Advanced visibility on top of the SQL-based data store
- Multi-cursor functionality - improves persistence resource utilization as well as providing better isolation between tenants

![Replay 2022 Lunch](//images.ctfassets.net/0uuz8ydxyd9p/3bf4hmTp4TIMZhFlwjFZaL/684e278c947511bf5ee0080a51a66ec7/DSC_0362.JPG)

Okay, so this was all amazing, but I’d be remiss if I didn’t talk about the food and how good it was. Normally I wouldn’t even mention the food, but I’m still drooling thinking about it. Replay provided slow roasted wild salmon served with a preserved lemon aioli, grilled sliced chicken breast with fresh basic aioli, seasonal roasted vegetable and quinoa cakes, wild rice pilaf with dried cranberries and walnuts, a tomato, couscous, fregola and fresh herb salad, and an arugula watermelon feta salad. *Hat tip to our fearless Amelia who helped keep us fueled with quality food.*
## Day Two: Talks
I’m going to go ahead and draw a line in the sand, my absolute favorite talk of the day was Maxim Fateev’s keynote, and this isn’t meant as a slight against all the absolutely amazing talks given throughout the day, but the incredible clarity of how Temporal does things vs the way things are traditionally done—[it’s Cake Architecture; not Smoothie Architecture](https://www.youtube.com/watch?v=ws78ih0FluU). As someone new to Temporal, I was particularly thankful for this insight on its own, but what made it even more beautiful to me was Maxim’s expression of emotion and appreciation for the community—making him more approachable and helping everyone feel welcome.

![Replay 2022 Maxim Fateev Keynote](//images.ctfassets.net/0uuz8ydxyd9p/2lOnr9vsNDNnr03u8NMIxg/86e7751a0d8d3ba5b474e2a38792921c/FbGnafPagAMtaVJ.jpeg)

We had so many amazing talks. Many of you were quite keen on Yum! Brands’ talk highlighting how they are building a next generation eCommerce Platform to power KFC, Taco Bell, Habit Burger, and Pizza Hut. And a fan favorite, Paul Nordstrom’s afternoon keynote, which explored the evolution of software by comparing it to the evolution OF THE WORLD.

Here is the good news: if you missed out on this conference, you can watch the recordings via the [Replay playlist on YouTube](https://www.youtube.com/playlist?list=PLl9kRkvFJrlRWBrfqOOX1rN_d1mahYI70). We know it’s not the same, but we hope you can still enjoy it, and we’d love to hear from you... which was your favorite?

For those that are wondering—YES there will be a Replay next year, for sure, Dinosaurs and all.

The conference was amazing, truly, but we aren’t stopping there. We have so many things planned for this upcoming year that you can’t see on the roadmap or in these talks. Best way to find out more information and ensure you don’t have Temporal FOMO? Find us on [twitter](https://twitter.com/temporalio) or [linkedin](https://www.linkedin.com/company/temporal-technologies/) or [youtube](https://youtube.com/temporalio).

![Replay 2022 Mary and Rain Dinosaur](//images.ctfassets.net/0uuz8ydxyd9p/kABYykOByYVt3VyCXPpuD/555bbbaeb035830a361c74507843e8e4/FbHZYtQVQAQz7qi.jpeg)

Personally I am leveraging the knowledge and momentum of Replay to dive into the [Python SDK](https://docs.temporal.io/application-development/foundations/?lang=python#add-your-sdk), build out a couple of applications to deepen my knowledge around Workflows, Activities, and metrics, and continue inhaling knowledge via the [monthly meetup](https://lu.ma/temporal), the [application development guide](https://docs.temporal.io/application-development/?lang=python), and [documentation](https://docs.temporal.io/). By next year I’ll experience the conference, not as one new to Temporal, but as an expert—maybe even as one of the people helping with the architecture review or running a Birds of a Feather; if anything, I know I look forward to seeing YOU at next year’s event!

Replay 2022 Application Architecture Review

Application Architecture Review

Temporal hosted its inaugural developer experience conference, encompassing everything from in-depth discussions around SDKs and live architecture reviews to Temporal 101 workshops, talks from Datadog, Stripe, Yum!, and, yes, actual real living dinosaurs.

Temporal's Inaugural Developer Experience Conference

Rain Leander

Rain Leander Headshot

Developers and Distributed Systems and Dinosaurs, Oh MY!!!

*This blog post is a public copy of our monthly newsletter sent on July 29. If you'd like to receive upcoming updates by email, you can [subscribe to our newsletter here](https://pages.temporal.io/newsletter-subscribe "Subscribe to the Temporal newsletter").* 

This month's newsletter features some exciting news and updates, including:

*   Our Typescript SDK v1.0.0 is now available! [Read more in this blog post ›](https://docs.temporal.io/blog/typescript-1.0.0)
*   [Replay](https://temporal.io/replay), Temporal's first-ever developer experience conference, is next month! Join us on August 26 in Seattle for talks from Temporal users at companies like Stripe, Datadog, Snap Inc, and Yum! Brands.

For more information on what we've been working on, just keep reading! And as always, we'd love to hear from you—feel free to share feedback in our [Community Slack group](https://temporal.io/slack) or on Twitter ([@temporalio](https://twitter.com/temporalio)).

Technology
----------

### Developer Experience

**TypeScript GA**: We are incredibly excited to announce that our TypeScript SDK is officially GA. This SDK has been a labor of love and a long time coming. It boasts an absolutely killer developer experience, powered by V8 isolation technology. We believe the TypeScript SDK represents the fundamental direction all of our future SDKs will go.

[Typescript SDK ›](https://github.com/temporalio/sdk-typescript)

[Typescript SDK test framework ›](https://docs.temporal.io/typescript/testing/)

**Web UI V2 GA:** Although the core technology of Temporal is a true game-changer, capitalizing on that value would be nearly impossible without high quality tools to support it. A year ago we took a hard look at our existing UI experience and realized it was holding the overall product back. Since then, we hired amazing Frontend and Design teams who have diligently worked to match our UI quality to what you've come to expect from Temporal. We are incredibly excited to announce that the experience is now GA! If you haven't already made the switch, we highly encourage it.

As part of this release, we are also planning to deprecate our previous Web UI. The timeline for that deprecation is **September 30, 2022**. That means you have a little over two months to switch to the new Temporal UI.

**Python Alpha:** Earlier this year we started developing a [Python SDK](https://github.com/temporalio/sdk-python) for Temporal. The team has been hard at work and immense progress has been made. It will still take a while before we can seriously target a GA release but the Alpha client is surprisingly full featured. We want to be incredibly clear that any Alpha/Beta release should not be used for critical workloads. That being said, we can never get too much community feedback about the SDK experience.

**Spring Boot Alpha support:** For those who are embedded in the Java ecosystem, developing applications without Spring Boot is almost absurd. That's why it's a little strange that Temporal's Java SDK has never had official bindings for the Spring ecosystem. We're serious about changing that, and this Alpha release is the first step in the right direction. [PR #1305 ›](https://github.com/temporalio/sdk-java/pull/1305)

**tctl V2 GA:** In the developer world there are really two groups, "UI people" and "command line people." We want to make sure the experience is equally great regardless of your tooling preference, so the team has been hard at work revamping the Temporal command-line tool `tctl`. The goal was to keep the experience familiar while removing the inconsistent developer experience, rough edges, and missing functionality. `tctl` V2 is now GA and will become the default in the next release.

As part of this release, we are also planning to deprecate `tctl` V1. The timeline for that deprecation is **September 30, 2022**. That means you have a little over two months to switch to the new `tctl`.

**Schedules Beta:** Cron jobs are everywhere and running them may seem simple on the surface, doing so reliably is much easier said than done. Fortunately, Temporal is designed for running time based workloads reliably at any scale. Unfortunately, our current cron experience leaves…well, a lot to be desired. The functionality is limited, the experience is confusing, and debugging things when they go wrong is seriously unpleasant. Due to these shortcomings, the team has poured their hearts into a fundamentally new experience. The improvements are so significant that we are even renaming the feature to Schedules. Schedules offer all the capabilities of the original cron functionality, but are also:

*   Easy to use
*   Straightforward to debug
*   Functionally rich
*   Fully extensible

We don't have a concrete timeline for GA of this feature, but we need **your** feedback. We encourage you to grab the latest server and tctl release and give the new experience a spin.

### See also

*   Eager activity dispatch for Python, TypeScript, and Go
*   Started development of a [Ruby SDK](https://github.com/temporalio/sdk-ruby)
*   [Local activities](https://docs.temporal.io/php/activities#local-activity) are available in the PHP SDK
*   Go SDK [v1.15.0](https://github.com/temporalio/sdk-go/releases/tag/v1.15.0) released
*   Java SDK [v1.14.0](https://github.com/temporalio/sdk-java/releases/tag/v1.14.0) released
*   Workflow deletion is available as a `tctl` command that does not require direct DB access from `tctl`
*   Namespace deletion is also now available as a `tctl` command
*   Host-level priority Task processing

Content and Community
---------------------

**Support team growth:** As many of you know, we take support seriously at Temporal. Historically the support workload has been carried by members of various engineering and product teams within the company. Recently, we’ve formalized this area of work and established an official support team. Until last month Tihomir (whom many of you recognize as your go-to resource for support questions, was our sole member of this team. We are incredibly excited to welcome two new support team members Antonio Mendoza and Jordan Reynolds. Antonio and Jordan both bring an intense passion for technology and helping others. They will be key in scaling the response and high-quality support we provide.

**Community knowledge base:** Temporal offers a few options when it comes to learning more or getting your questions answered. We have our support forum for standard Q&A, Slack for community engagement, and docs for establishing foundational product knowledge. In general we are very happy with these solutions, but recently we felt that some classes of questions that aren’t being well addressed. In an attempt to solve for this class of questions, we are experimenting with adding a knowledge base to our community support forum ([community.temporal.io](https://community.temporal.io/)). Our hope is that this knowledge base will surface a set of information that is not covered by the docs or easily discoverable on the support forums. We are especially interested in hearing your feedback on this one!

**Python in the Application development guide:** A few months ago we released a new style of product documentation that aimed to provide a cohesive narrative instead of “requiring assembly.” So far this new approach has been well received and therefore we are confident to continue in this direction. Considering the immense progress we have made in developing the Python SDK, adding Python to the app dev guide seemed like a no-brainer. The content isn’t fully complete, but most of the Foundational section has been updated to include Python at this point. [Python in the Application development guide ›](https://docs.temporal.io/application-development/?lang=python)

**Observability section of Application development guide:** In addition to supporting new languages for existing App dev guide content, we are also adding net new information to help guide your development journey. The guide now has a section about [observability](https://docs.temporal.io/application-development/observability/), which continues to be one of the most requested topic areas in Temporal.

**New home for tutorials:** Historically all learning content has lived on [docs.temporal.io](https://docs.temporal.io). But with the founding of our Education team earlier this year, the landscape is changing. Moving forward, learning content will be available over at [learn.temporal.io](https://learn.temporal.io), and the majority of our existing learning content has already been migrated. For now, the migrated content makes up the entirety of the learning site, but that won’t be the case for long. Stay tuned for some very exciting educational updates coming from the team!

### See also

*   Check out our new [Community Ask and Learn](https://www.youtube.com/playlist?list=PLl9kRkvFJrlRh_OrohmwIvE8OsXSsi7QV) video series
*   [Temporal Cloud release notes](https://docs.temporal.io/cloud/release-notes/) are now available
*   [Experimental Schedule feature documentation](https://docs.temporal.io/workflows#schedules) is now available
*   Last call for feedback on our [quarterly docs survey](https://forms.gle/VWgQdPbV5qa8zJVBA)
*   \[Video\] [Temporal Explained: Idempotence](https://www.youtube.com/watch?v=JpBNKuYMB10)
*   \[Video\] [Temporal Flagship Community Meetup - June 2022](https://www.youtube.com/watch?v=yPZK82Kwe3o)

Community Spotlight
-------------------

Very few things that make us more excited than seeing community-created Temporal content, which is why we're so excited about this:

[Write your first Temporal workflow in Typescript ›](https://www.bitovi.com/blog/write-your-first-temporal-workflow-in-typescript)

We missed this when it was originally published, but fortunately it was recently shared with the team and it made our collective day. In this post about developing Workflows in TypeScript, Michael Haynie does an outstanding job of presenting a practical and digestible path for getting started with Temporal. If you've been waiting for that extra push to get started with our now-GA TypeScript SDK, wait no longer. Posts like these are what make our community so great and we would love to see more! The team is always happy to support content creators, so if you're looking for technical feedback, or a spelling check, or you're just feeling a bit anxious about putting something out there, you're not alone.

### Twitter thread of the month

[![Dominik tweet: Are compensating actions a defining component of sagas or a frequent but non-defining component of sagas?! Well ............ What even are compensating actions?!?!](https://pages.temporal.io/rs/250-WIU-007/images/dominik-tornow-saga-showdown.png)](https://twitter.com/DominikTornow/status/1547685647975997440)

Check out [@DominikTornow](https://twitter.com/DominikTornow/status/1547685647975997440) on "The Saga Showdown."
