Replay 2023 - CFP Deadline Extended!

Community friends, we have some news… the CFP has been extended [another 10 days](https://www.papercall.io/replay-cfp-2023) until the **31st of May**! We heard from you and since this is our first year doing this format, we want to ensure we give everyone a chance to share their ideas.

Some key reminders for those who missed the announcement post. We are looking for these types of talks:

- Platforms and technologies that make us rethink backend engineering
- Innovative, general engineering practices that have an impact on velocity, productivity, and quality
- Temporal use cases: _how successful services & applications were designed and built using Temporal or lessons learned from failures_
- How to tame complexity & improve reliability in services and systems

Also new this year is a speaker program to help refine your talk. So if you have a great idea, but are a bit nervous about presenting, don’t worry, we’ve got you covered! Our team is ready to help you work through your outline, deck presentation and give you some pointers on public speaking. 

In the meantime, we do have tickets available for [purchase](https://temporal.io/replay#tickets)! We will be in the beautiful Seattle area again and at the end of summer, so it will be a great time to visit and chat about all things technology. 

Looking forward to hearing from you! 

blog post replay

Replay 2023 CFP deadline extended 

Head of Developer Relations and Community

Jessica West

jesswest

Replay 2023 - CFP Deadline Extended

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

This month's newsletter features some exciting news and updates. We've got lots of new content from our DevRel team including blogs and videos, plenty of chances to see users at upcoming events, and Temporal v1.20 updates!

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)), or simply reply to this message.

## Temporal v1.20

Notable new features:

__Simplify your local development environment with the Temporal CLI.__ Now you can run Temporal without containers by leveraging our new Temporal CLI, which supports convenient installation with [curl, Homebrew, or binary downloads.](https://github.com/temporalio/cli?mkt_tok=MjUwLVdJVS0wMDcAAAGK9nFkNE4BISb3zHRh0VQQ5QEt8U5L--FQupvK5NudiujeQfS5_W7KeOm6433kJJK7jR95PwWnIOCFKJtu-A#installation)

__Scheduled Actions: The new way to schedule Workflows in Temporal.__ Scheduled Actions gives you significant new controls over scheduling Workflows, supports a robust set of new input formats, overlap and catchup policies and more.

For more information on what’s included in the Temporal v1.20 release, [check out our blog post.](https://temporal.io/blog/temporal-v1-20-lighter-and-simpler-development-environments-and-improved)

We have several new updates to the server, see what has changed here:

__Advanced Visibility on SQL -__ This change makes it possible to run the full Visibility API with standard persistence (such as MySQL and postgreSQL). With this update, we are also deprecating Advanced Visibility support for Cassandra.

__Archival overhaul -__ This overhaul addresses these design issues and ensure that the functionality is entirely reliable. We’ve also made it possible to set a Retention Period of longer than 30 days.

__Workflow Update fast path (Alpha) -__ Workflow Update will eventually provide a unified Signal/Query experience for most use cases. Only Update calls made from a client outside Temporal will be supported initially. Workflow-to-Workflow Updates are planned for the future.

__Replication between different Shard counts -__ Cross-shard replication makes it possible to replicate between Clusters that have different shard counts.

__Improved default authorizer as part of v1.20 -__ previously there was special handling required for temporal-system and empty namespace, this is no longer required.

__DeleteWorkflow -__ this feature is now supported in the Batch API.

*[__Temporal v1.20 Webinar:__](https://pages.temporal.io/thank-you-on-demand-webinar-temporal-launch1.20.html) in case you missed our webinar on March 30, check out the Youtube out now on the latest Temporal release v1.20*

### SDK Updates

- .NET Activity Worker and Client support is now out, with a Workflow Worker hot on its trail.
- Context aware data converters in Java - Java SDK now supports context making this possible. We’ve also extended Data Converter to work on error messages and stack traces.
- Eager Workflow Start Java - Our Eager Workflow optimization can significantly lower the start latency for Workflow Executions.
- Workflow Update in Go - we added Alpha support for our new Workflow Update functionality. Workflow Update combines the power of Workflow Signals and Workflow Queries into a single Request/Response style primitive. Go SDK now officially supports this new Workflow Update functionality, so let us know what you think.
- Python support for our new Scheduled Workflows functionality.
- Java SDK AOT compilation support via GraalVM.

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

## Content and Community

We've got lots of new learning tools available for several SDKs!

- Learn how to build a Temporal application in Python with this lesson: [Tutorial: Build a Temporal Application from scratch in Python](https://learn.temporal.io/getting_started/python/hello_world_in_python).
- Interested in Typescript? We've got you covered! [Take the Temporal 101 class in TypeScript!](https://learn.temporal.io/courses/temporal_101/typescript)
- If Go is for you, don't worry! We've got content coming up for that soon! [Sign up to be notified about Temporal 102 in Go!
](https://learn.temporal.io/courses/temporal_102)
__Upcoming meetups & events:__

- __March 30th__ | [Join us for a meetup in London](https://www.meetup.com/temporal-community-meetup/events/292091122) with Temporal & Vonage, featuring: Maxim Fateev, Temporal and Benjamin-Michael Aronov, Vonage.
- __April 12-14__ | Come see us at [DevOxx France](https://www.devoxx.fr) in Paris! We'll also be hosting a meetup with Datadog on April 11. More info to come.
- __April 20-22__ | We'll be in Salt Lake City, Utah, for [Pycon US](https://us.pycon.org/2023/attend/information)! Join us for a meetup on April 19 to kick off the event. More info to come.
- __April 23-25__ | [Join us at DevOpsDays](https://devopsdays.org/events/2023-denver/welcome) in Denver! We're keeping the party going and hosting a meetup on April 26 featuring: Kim Schlesinger, Temporal and Alex Goldman, Twilio. More info to come.

*__[Replay CFP:](https://temporal.io/blog/replay-cfp-and-why-you-should-submit)__ We want to hear from you! Find out how you can be a part of Replay 2023 and submit a CFP today!*

## Community Spotlight

We wanted to highlight this awesome article written by one of our community members about their thoughts from attending Dominik's latest webinar on Sagas!

Check out [Sagas in Microservices: Managing Complex Transactions in Distributed Systems](https://blog.bitsrc.io/sagas-in-microservices-managing-complex-transactions-in-distributed-systems-58d40f365eb4).

![community-spotlight-article](//images.ctfassets.net/0uuz8ydxyd9p/cRbP2GH5sRHt1twtzljng/05d739ad4bf8b424896c999d190519f9/community-spotlight-article.png)
### Community Favorites

- __[Funding Round:](https://temporal.io/news/temporal-investors-expand-funding-with-usd75m-round)__ Check out this blog on our latest round of funding and how we kept unicorn status.
- __[Typescript 101 course:](https://temporal.io/blog/temporal-101-learn-temporal-with-typescript)__ For part of our Typescript week, we released a new Temporal 101 course.
- __[Python SDK release:](https://temporal.io/blog/python-sdk-the-release)__ We recently had a week all around Python content; here is our first post from the series.

Please, [reach out on our Community Slack](http://temporalio.slack.com) and let us know if you are building or migrating applications to Temporal and need design assistance. Or request a video covering best practices via [support.temporal.io](http://support.temporal.io) or [#support-cloud](https://temporalio.slack.com/archives/C046BRWDV2R).

Also, don't forget to take a look at the [March changelog for Temporal documentation](https://docs.temporal.io/changelog/march-release-2023).

###  Meet the DevRel team:
![devrel_team](//images.ctfassets.net/0uuz8ydxyd9p/WiOhUWRTnHei72Bc8iqqW/15f2ea85a8023829b8a664f727f48f4e/Screen_Shot_2023-02-01_at_11.29.34_AM.png)

social-orb

This month's newsletter features new content from our DevRel team including blogs and videos, plenty of chances to see users at upcoming events, and Temporal v1.20 updates!

Temporal Community Newsletter: March 2023

Charles Zedlewski

charles zedlewski

> London Calling, Yes, I Was There, Too

Temporal was absolutely chuffed to attend and sponsor the [2023 PHP UK Conference](https://www.phpconference.co.uk/) in London England 14-16 February.

![Temporal's Booth at PHP UK Conference](//images.ctfassets.net/0uuz8ydxyd9p/1kRbWzhGPh9qU4kAfsxcfi/e3490a7c802a867f26acc3027395b5ff/40E1E9A9-F6E3-4E81-B46B-58A904F50CCA.JPG)“The largest dedicated PHP event in Europe, PHP UK welcomes hundreds of leading developers to London for three days of workshops, talks, networking and socials. Join us for an event packed with up-to-date content about PHP development and related technologies in a comfortable and professional setting.”

And since we were in town for the conference, we threw a [London based Temporal Community Meetup](https://www.meetup.com/temporal-community-meetup/events/291337514/) and met with customers and partners throughout the week.
## Highlights
The conference had a number of amazing talks, but there were a few that stood out to us that we wanted to share with you. The whole conference was recorded, so you can find all talks online if you want to hop around the conference after the fact. 

### [Your Software is Mission Critical](https://www.youtube.com/watch?v=Eag8mbIWR_0&t=988s)
If an autopilot fails, or a weapon system malfunctions, lives can and will be lost. As a result, significant checks, practices and concepts go into designing the software for such systems. But the code we, as developers in a wide range of jobs and fields, write can be just as critical - a delayed benefits submission because of a server error causes somebody to become homeless; a mistake on an immigration system causes a family to be deported; a misrouting of a delivery driver causes a car crash. As developers we should explore the culture around what we build - move fast and break things doesn't work if you're dealing with real people's real lives. Are there lessons of software development, design, project management, that we can learn from "mission critical" software production, and apply to our "normal" development projects that can ultimately save frustration, jobs and even lives in the process?

### [We built this city... The geographies of software development](https://www.youtube.com/watch?v=9r-0RQFRU20&t=2116s)
As developers we assume the responsibility of planning, architecting, building and maintaining our individual patches of cyberspace. Our codebases are the landscape of our virtual cities and this landscape must be cared for. From the perspective of a geography graduate turned software engineer, let's explore the parallels that exist between the built environment we inhabit and the virtual environment we are creating.

![Diving Into New Technologies: Hacks to Work More Efficiently](//images.ctfassets.net/0uuz8ydxyd9p/5HTIzyfib3NeLt9zM6GT98/6645db51d3cb3bb93a777679dba88f1e/71F2F289-AD31-4FC5-A1C3-CBE7599595B7_2.JPG)
### [Diving Into New Technologies: Hacks to Work More Efficiently](https://www.youtube.com/watch?v=9r-0RQFRU20&t=28110s)
As a Software Developer, we’re expected to inhale new technologies from the latest libraries within PHP 8.2 to performance driven development, from dissecting PHP’s type system to effective code review, from taking over a legacy project to Rapid Application Development practices within Symfony. Throughout the PHP UK Conference, we have touched on several technologies and now we’re inspired to take a deeper dive. This talk is not just for those who want to hack their learning process, but also for managers who want to support their people learning on the job, and further, for mentors who want to supplement their protégé’s learning process.
## Resources
If you’d like to explore the Temporal PHP SDK, check out the following resources.

- [Temporal’s Get Started with PHP](https://temporal.io/get-started-with-php) how to build a fault tolerant application in PHP
- [Temporal PHP SDK](https://github.com/temporalio/sdk-php) the framework for authoring workflows and activities using PHP language
- [Temporal’s PHP Developer’s Guide](https://docs.temporal.io/dev-guide/php) provide a comprehensive overview of the structures, primitives, and features used in [Temporal Application](https://docs.temporal.io/temporal#temporal-application) development
- [LaraBelles](https://larabelles.com/) a community for Laravel developers under-represented due to their genders

![The PHP UK Conference Sponsors Room](//images.ctfassets.net/0uuz8ydxyd9p/5D69JCCGI8ImRfWsybs3hW/90387da95f05382d6b2be5f5a3c9de09/F98784EA-71A7-4F0C-B8AD-369A822F82F7_3.JPG)
## Upcoming Events
Languages aside, if you’re interested in joining the Temporal community, there are several opportunities to get involved this year.

- [Temporal In Person Community Meetup](https://www.meetup.com/temporal-community-meetup/) : Temporal's Developer Advocates are coming to a place near you for a conference and would like to highlight Temporal's latest features, incredible customers, and insightful workshops. Keen to join? Want to give a talk? Interested in using an open source engine to eliminate complex error or retry logic, avoid callbacks, and ensure that every workflow you start, completes? Join the group and let us know!
- [Temporal Virtual Flagship Community Meetup](https://lu.ma/temporal) : Last Tuesday of every month! We’d especially love to take your questions live. Our community events are recorded and shared on YouTube and Twitter.

![Thank You PHP UK Conference](//images.ctfassets.net/0uuz8ydxyd9p/5gSBvi095IPMnLItbvQzQ0/9db32c142220a67f79f27f8aee335fbc/5031C046-E5D0-4FDD-BFA5-97F6EC8F4739.JPG)

- [Scale 20x Conference](https://www.socallinuxexpo.org/scale/20x) : 9-12 March 2023 : SCaLE 20x – the 20th Annual Southern California Linux Expo – will take place in Pasadena, CA. SCaLE is the largest community-run open-source and free software conference in North America. It is held annually in the greater Los Angeles area.
- [QCon London](https://qconlondon.com/) : 27-19 March 2023 : Make the right decisions by uncovering how senior software developers at early adopter companies are adopting emerging trends. Learn the emerging trends. Explore the use cases. Implement the best practices. Attend in-person or online. QCon London international software development conference. 
- [DevOxx France](https://www.devoxx.fr/) : 12-14 April 2023 : Devoxx are annual technology conferences organized by developers for developers around the world.
- [PyCon US](https://us.pycon.org/2023/) : 19-27 April 2023 : At PyCon US 2023, you will find an amazing program filled with pre-conference tutorials and sponsor presentations, 90+ of our community’s best talks, which includes our Charlas track, brilliant keynote speakers, a lively Expo Hall filled with our incredible Sponsors’ booths, and our famed lightning talks on each main conference day. Following the conference days, there are 4 days of sprints that are free and open to the public and offer an opportunity for anyone to collaborate and contribute to a project even if it is their first time.

Temporal's Booth at PHP UK Conference

Temporal was absolutely chuffed to attend and sponsor the 2023 PHP UK Conference in London. Read more about the event here!

London Calling Temporal

Developer Advocate

Rain Leander

Rain Leander Headshot

Hey friends, we are SO excited to announce that Replay is back this year, and more importantly, we are opening our CFP up to hear from you!

*tl;dr: [Submit your ideas by May 20th](https://www.papercall.io/replay-cfp-2023) for [Replay 2023](https://temporal.io/replay) happening September 12-14th in Seattle!*

Last year we held our very first conference in Seattle, Washington. We had two packed days with workshops and talks that ranged from use cases to the Temporal roadmap to being a change catalyst to the age old topic workflows vs sagas. 

This year, we are going even bigger with more workshops, multiple tracks and additional full day of content. It’s going to be an exciting 3 days, and we would love for you to be part of it.

We need your help to make the 2nd annual Replay the best one yet. The main conference will have slots for 45 minute presentations and 15 minute lightning talks.  We also welcome your proposals for hands-on pre-conference workshops.

We want to hear from you and have a few guidelines we recommend to make it the best possible opportunity for you to speak. 

__We are looking for talks about…__
- Platforms and technologies that make us rethink backend engineering
- New backend engineering practices that have an impact on velocity, productivity, and quality
- Innovative use cases - how successful services & applications were designed and  built or lessons learned from failures
- Architectural renewal: patterns and antipatterns
- Improving the developer experience
- Platform engineering by and for developers
- Taming complexity & improving reliability in services and systems

__Please refrain from…__
- Giving a product pitch.
- Disparaging other companies, languages, or frameworks.
- Submitting third-party submissions.

This year we are launching a program to help new speakers. If you have a great idea, but have given under 5 talks before (including no talks!), this is the program for you! Our Developer Relations team can help you with the best way to take an outline to slides, give you two talk reviews, and ensure you are in the best shape possible for your talk! Make sure to tick the “new speaker” box in the CFP area. 

Here is the [link](https://www.papercall.io/replay-cfp-2023) to apply to speak. The CFP will close on May 20, 2023; we will review all talks and will have a decision for you by June 10, 2023. If you do not hear from us, please know that we are doing our best to go through things in the quickest way possible. We may reach out for clarification on your talk in the interim, but everyone should have an answer by June 10, 2023.  If your talk isn’t accepted for whatever reason, we may reach out to you to speak at one of our meetups instead. We want to encourage all types of conversations amongst our community!

For us, Replay is more than a user conference and a community gathering. We want it to be a source of innovation to help our community create projects we never even dreamed of! Our founders started this company with open source in mind and we are continuing to drive towards that by being good citizens in the community. Our goal is to create an excellent product that you can use and build upon. 

We are 196 days away from the conference and 81 days until [the CFP](https://www.papercall.io/replay-cfp-2023) closes. We’d love to hear from you and hope that you can join us in Seattle this year, regardless! 


social-waves

Hey friends, we are SO excited to announce that Replay is back this year, and more importantly, we are opening our CFP up to hear from you, our community!

Replay CFP and Why You Should Submit

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

We're excited to jump into the new year and have lots of exciting events planned for 2023! From meetups and blogs to workshops and webinars, we've got a ton of awesome content coming you're way, and we can't wait to share it with you!

Don't miss the chance to come hang out and talk all things Temporal with us at [PHP UK](https://www.phpconference.co.uk/) this February! Mark your calendars and grab tickets early to secure your spot.

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)), or simply reply to this message.
![meetup sf](//images.ctfassets.net/0uuz8ydxyd9p/7FHwMInlwDkxJu8DoyuUVl/dd9ffcbf033fdcc87656a54265b06305/meetup_sf.png)

## Technology

__Python SDK General Availability.__ [Python SDK](https://pypi.org/project/temporalio/) version 1.0.0 was released and is now generally available (yay!). We strongly encourage alpha and beta users to upgrade to this stable release.

__Ruby SDK.__ The official Temporal [Ruby SDK](https://github.com/temporalio/sdk-ruby/) now supports running activities. A fully-featured SDK with workflow support is in the works.

We added a Task priority rate limiter for the background Task processing system. The history scavenger to clean up orphan Workflow data was improved as well.

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

__Meetups in the new year.__ Our first meetup was January 24, featuring Ashish Ranjan and Sachin Bansal from Maira and Andrey Dubnil from Maersk. Maira talked about their low-code platform they built on top of Temporal. To be a part of future conversations like these, sign up to join our monthly [Flagship Community Meetup](https://lu.ma/temporal)!

__Upcoming events.__ It's not just meetups that we have going on right now. The [PHP UK Conference](https://www.phpconference.co.uk/) is right around the corner, and we're sponsoring! We can't wait to see our EU community on February 14-16 in London.

__Onboarding sessions.__ New onboarding sessions are offered to new Temporal Cloud users. These sessions cover everything needed to ensure a successful start, from account and users setup to Namespace planning, SDK overview, Worker deployment, monitoring, and alerts.

__Design sessions.__ We also have design sessions in the works that will be offered to Temporal developers using both Cloud and OSS. These sessions get into specific design considerations (such as activities versus. local activities) and best practices, including Activity/application failure, versioning, timeouts, Worker setup optimization, and how to avoid common issues (such as “context deadline exceeded”). Weekly office hours for these sessions launch in February.

__[Understanding and debugging event histories.](https://youtu.be/nBKyz6jMOlc)__ Tihomir Surdilovic, Principal Developer Success Engineer, hosted a hands-on workshop on January 19. Check out part one of this workshop series on our YouTube channel. And don’t forget to [register for part two](https://lu.ma/of440qho) coming up on February 16. We look forward to seeing you there!

__[How to test your Workflows and Activities section of the Developer's guide.](https://docs.temporal.io/dev-guide/typescript/testing)__ This section was expanded significantly to cover many aspects of testing your application code, such as testing frameworks, replays, skipping time, Heartbeats, and cancellation. The only caveat is that most of the available samples are in TypeScript. However, more are on the way!

__[Setting up Prometheus and Grafana to view metrics (OSS).](https://docs.temporal.io/kb/prometheus-grafana-setup)__ The Temporal Cluster and SDKs emit metrics that can be used to monitor performance and troubleshoot issues. After you enable your monitoring tool, you can relay these metrics to any monitoring and observability platform.

__[Setting up Prometheus and Grafana to view metrics (Cloud).](https://docs.temporal.io/kb/prometheus-grafana-setup-cloud)__ Learn how to set up and monitor Cloud performance metrics.

__[Troubleshooting the DeadlineExceeded error.](https://docs.temporal.io/kb/deadline-exceeded-troubleshooting)__ All client-side requests made to the Temporal Cluster are gRPC requests. Sometimes, when these requests can't be completed, you'll see this particular error message: "Context: deadline exceeded.

__[Why you shouldn't use Run Ids in Workflow logic.](https://docs.temporal.io/kb/non-determinism-issues-for-run-ids)__ The current Run Id is mutable and can change during a Workflow Retry. You should not rely on storing the current Run Id, or using it for any logical choices, because a Workflow Retry changes the Run Id and can lead to non-determinism issues.

__[An overview of failure categories.](https://docs.temporal.io/kb/failures)__ There are several categories of “failures” that one must navigate while using the platform. This article provides an overview of each.

__[Overview of Python SDK sandboxing.](https://docs.temporal.io/kb/python-sandbox-environment)__ The Temporal Python SDK enables you to run Workflow code in a sandbox environment to help prevent non-determinism errors in your application.

__Cross-platform search.__ When you use the [docs.temporal.io](https://docs.temporal.io/) site search feature or the [learn.temporal.io](https://learn.temporal.io/) site search feature, the results include both sites. This means you can search for tutorials on the docs site or core concepts from the learn site.

__Link previews.__ When available, on hover, local site links provide a preview of the destination content.

### Meet the DevRel team:
![devrel_team](//images.ctfassets.net/0uuz8ydxyd9p/WiOhUWRTnHei72Bc8iqqW/15f2ea85a8023829b8a664f727f48f4e/Screen_Shot_2023-02-01_at_11.29.34_AM.png)
### See our latest blog posts:

- "[The Linear Developer Experience](https://temporal.io/blog/the-linear-developer-experience)" from Dominik Tornow. Be on the lookout for other exciting content around this topic in the near future.
- For our Star Wars enthusiasts: "[Do...Or Do Not: Why Yoda Doesn't Use Microservices](https://temporal.io/blog/do-or-do-not-why-yoda-doesnt-use-microservices)" from Samar Abbas
- [How we built it: Building Scheduled Workflows in Temporal](https://temporal.io/blog/how-we-build-it-building-scheduled-workflows-in-temporal) from David Reiss
- [Building Reliable Distributed Systems in Node](https://temporal.io/blog/building-reliable-distributed-systems-in-node) from Loren

## Community Spotlight
### Twitter thread of the month
![dominik twitter](//images.ctfassets.net/0uuz8ydxyd9p/2rpWW5Hb1a0iR7rkdKz0yL/08f3cd6484943973f8160b6cf63ab416/dominik_twitter.png)
Check out [@DominikTornow](https://twitter.com/DominikTornow/status/1615760997331136514?s=20&t=2Bg56ZDOK27smy236s7kwQ) on "Thinking Distributed Systems"

shubham-dhage-C8YfO3YStVo-unsplash

We're excited to jump into the new year and have lots of exciting events planned for 2023! From meetups and blogs to workshops and webinars, we've got a ton of awesome content coming your way, and we can't wait to share it with you!

Temporal Community Newsletter: January 2023

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

*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)

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)


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

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/dev-guide/python/), 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/dev-guide/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

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/dev-guide/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/dev-guide/go/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."


mo-U3Kst7MY4Ok-unsplash

This month's newsletter features exciting news including our Typescript SDK v1.0.0 availability, and Replay, Temporal's first-ever developer experience conference!