eric wu

With over 7 years of experience in product marketing, I am passionate about creating and delivering impactful marketing strategies that drive customer value, business growth, and competitive differentiation. I have a strong background in launching new products, especially in Security, Generative AI and Cloud domains, where I have led several successful end-to-end product releases. I currently work as a Senior Product Marketing Manager at Okta, a leading identity and access management platform that empowers organizations to securely connect their people and technology.

Product Marketing Manager - Customer Identity Cloud

Eric Wu

Free your developers to innovate! Auth0 simplifies identity, enhancing security and accelerating product launches.

Businesses are feeling market pressures to innovate faster by integrating AI capabilities into applications and customer-facing products. For smaller or leaner companies, agility is key to differentiating from established market players with new products, features, and capabilities.  

AI-powered innovation creates opportunities for transformation and relies on getting identity and authentication right. However, building customer identity is complicated. It requires extensive engineering skills, data processing, and infrastructure resources, and it creates identity management burdens.

## How Building Identity and Authentication Slows Innovation

Customer identity looks simple on the surface. In reality, robust authentication and authorization take a lot more than a user interface, a backend database, and a few API calls. Significant time and effort go into:

* **Scaling across different user types: **Different types of identities — consumer, business, and non-human** — have specific requirements. Your developers need to deliver seamless access across all apps, products, and services, but they often run into challenges related to identity federation, protocol management, and session orchestration. 
* **Updating the solution:** Identity constantly evolves with new threats and standards. Keeping identity systems current is necessary to stay ahead of threats. However, implementing advanced protections like phishing-resistant multi-factor authentication (MFA), passkeys, and adaptive risk-based authentication is a heavy lift for engineering teams.
* **Managing integration:** Integration with enterprise systems, third-party apps, and partner platforms adds friction and data flow complexity. Self-managed solutions demand new connectors, policy configuration, and complex API integrations.
* **Adhering to changing compliance requirements:** Ongoing compliance with shifting standards and region-specific data residency laws is a constant burden.

All these hurdles slow down productivity and data pipelines and divert focus from building new app functionality, planning future tools, or launching key features that drive innovation and business growth. The challenges of identity systems are twofold:

For engineering leads, authentication is not a one-time project. DIY systems require constant management — an ongoing set of workflows that impact everything from secure login flows and the user interface to data protection and user analytics. It takes a significant effort to detect suspicious login activity, secure APIs, and enhance authentication features to meet new standards and regulations. Not all companies have the budgets to hire engineers with specialized skill sets, especially when headcounts are limited.

For product leaders, self-managed identity exacerbates user adoption challenges and time-to-market pressures. Logins fail, onboarding becomes clunky, and Single Sign-On (SSO) implementations break — resulting in abandoned sign-ups, decreased adoption, increased churn rates, and more support tickets. 

These hurdles can stifle transformation and lead to missed opportunities. But what if identity wasn’t a limitation but instead a launchpad for innovation?

## Clearing the Way for Creativity: Making Customer Identity Easy

A developer-friendly, robust customer identity platform eliminates the pain of balancing innovation with secure implementation and infrastructure constraints — streamlining engineering workflows, automating compliance tasks, and giving product builders more time to focus on creating the next killer tool or capability. 

By offloading customer identity to a dedicated, dev-friendly platform like Auth0, your developers can:

* Reclaim engineering hours and redirect them toward planning new features, designing more intelligent user interfaces, or optimizing analytics workflows. 
* Easily monitor, manage, and troubleshoot user accounts without building new dashboards and admin tools.
* Make it simple to deliver seamless and secure access for customers without disrupting their experience.
* Roll out new authentication features like passwordless or biometric logins** **faster without impacting users.
* Automate and orchestrate identity flows to improve efficiency and get to market faster.

Instead of maintaining authentication, your developers can focus on strategic projects, rapid iteration, and breakthrough transformation.

### Set your developers free with Auth0

Auth0 provides a flexible platform and support that simplifies your identity so you can focus on building great products rather than on identity requirements. The Auth0 identity platform solves both infrastructure and productivity challenges by providing the following:

* **Prebuilt user onboarding flows** to streamline sign-up and login with preconfigured, customizable onboarding workflows.
* **Flexible integration options** to connect identity seamlessly with any tech stack — in on-premises, cloud, cloud-native, container, and hybrid environments.
* **Federated identity and SSO** to enable smooth access across multiple apps and services.
* **Adaptive MFA **to enhance security while reducing user friction with intelligent, risk-based authentication.
* **A user management dashboard** to easily monitor, manage, and troubleshoot accounts without building new admin tools.
* **Comprehensive logging and analytics** to gain insights into authentication trends, suspicious login attempts, and user behavior.

For example, financial institutions like [Nutmeg](https://auth0.com/case-studies/nutmeg) use Auth0 to offload identity, accelerate innovation, and simplify compliance — building a scalable digital banking experience while focusing on their core mission. Companies with small engineering teams like Checkr use Okta to scale efficiently while streamlining identity management, improving security, and supporting rapid growth.

### Simplify identity and accelerate innovation with Auth0

Differentiating through the user experience and accelerating time to market are key success drivers in a competitive market. Moving identity to Auth0 eliminates the complications of building, integrating, and maintaining your identity. Making things easier and simpler for developer and product teams empowers them to prioritize core product innovation — and embrace opportunities that drive growth.

> Learn more about [Auth0](https://auth0.com/secure-smarter), explore [Auth0 and AI advancements](https://www.auth0.ai), and [connect with us](https://auth0.com/contact-us).

Offload Authentication and Clear the Way for Creativity

ana-cidre

Ana Cidre is a passionate advocate for the developer community and leads the Developer Advocacy team at Auth0. She's committed to fostering a more inclusive and diverse tech world, drawing on her technical background and strategic vision to improve developer experiences and build meaningful connections.

 

As the founder of GalsTech, an initiative supporting women in tech in Galicia, and through her active efforts to create welcoming spaces for underrepresented groups, Ana's dedication to diversity and inclusion extends beyond her daily work.

 

Ana has a proven track record of building global Developer Relations teams, cultivating active developer communities, and crafting impactful educational content. She maintains a strong connection to the community through speaking engagements and direct interaction with developers.

Sr Manager, Developer Advocacy

Ana Cidre

Auth0 May 2025 updates: async auth (CIBA), CLI tools, real-time event streams, and customizable Universal Login. Enhance security, UX, and integrations.

May brought a wave of powerful new capabilities for you: async authentication flows with CIBA, fine-grained M2M quotas for secure API usage, expanded event streaming for automation, and even more control over the Universal Login experience, including WebAuthn and biometrics.

If you’re building with Auth0, this month’s releases give you more control over UX, security, and system integrations with less friction.

## Let’s Dig In

### Client-Initiated Backchannel Authentication (CIBA) – Now GA

![Client-Initiated Backchannel Authentication (CIBA) – Now GA](https://images.ctfassets.net/23aumh6u8s0i/74Extty3wWiKZ9ZDNwoHUd/d20ed90066e9535cf980ab1399b71485/CIBA.png)

The **CIBA flow** is now Generally Available, and it's a game changer for devs building across devices, services, and roles.

It enables **asynchronous authentication** where:

* One device **initiates** the request (e.g., a smart TV, AI agent, CLI tool)
* Another device **authenticates** the user (typically a mobile app with Guardian SDK)

**Highlights:**

* Works great for headless UIs, customer service flows, or AI agents needing human approval
* Built on **Rich Authorization Requests** (RFC 9396)
* Auth can happen off-screen, out-of-band, or in-context

> Explore CIBA in the [docs](https://auth0.com/docs/get-started/authentication-and-authorization-flow/client-initiated-backchannel-authentication-flow/user-authentication-with-ciba).

### Auth0 CLI: More UX control, better testing, new powers

The latest CLI update gives developers even more hands-on control over login, org testing, and tenant config.

New capabilities:

* Customize Universal Login from the CLI
* Block/unblock users programmatically
* Use `test login` with Organizations
* Better logs + user management commands
* Bug fixes + smoother workflows

> Check the [CLI reference](https://auth0.github.io/auth0-cli/).

### Event Streams for extensibility – now in Early Access

Already loved for user lifecycle events, **Event Streams** now support **Extensibility Events**.

This means you can:

* Subscribe to changes in users and organizations
* Route real-time events to Webhooks or EventBridge
* Build automation and observability into your dev workflow

Use this to sync downstream systems, trigger CI/CD pipelines, or log important changes without polling the Management API.

> Set up your [stream](https://auth0.com/docs/customize/events/create-an-event-stream).

### Universal Login: WebAuthn, Biometrics, and Logout – now customizable

![Universal Login: WebAuthn, Biometrics, and Logout – now customizable](https://images.ctfassets.net/23aumh6u8s0i/5RJDBKzJH664XABPw5VAf2/a534dc8277dbce2bae3bd67f3db5911d/Universal_Login.png)

The [Advanced Customizations for Universal Login (ACUL)](https://auth0.com/docs/customize/login-pages/advanced-customizations) SDK just leveled up.

You can now build client-rendered, pixel-perfect versions of:

* **MFA with WebAuthn** (roaming + platform)
* **Biometric flows**
* **Reset password screens**
* **Logout states** (completed, error, aborted)

### Tooling support:

* ACUL SDK
* Auth0 CLI
* Deploy CLI
* Terraform Provider

No more default templates - your login experience, your UI, your rules.

### More cool features we have shipped to improve your experience: 

#### Universal Login language selector for end users

Tired of relying on browser headers or `ui_locales`? You can now **let users choose their preferred language** directly on Universal Login pages using Custom Prompts.

#### Fine-Grained M2M Token Quotas (now in Early Access) 

Allows you to set precise hourly and daily limits on machine-to-machine token issuance at the app or organization level. This helps prevent API abuse from misconfigured clients, returns automatic 429 responses when limits are hit, and provides full visibility through logs and response headers. No external rate limiting or token caching hacks required.

#### Native Sign-in with Google for Android

If you’re building native Android apps, you can now use the **Android Credential Manager’s Sign in with Google** to let users authenticate seamlessly using their existing Google sessions - no passwords, no extra prompts.

## Community and Events

### Where we were in May

May took us around the world—from live webinars to some of the most exciting developer and API conferences.

* **Qiita Webinar with Twilio** &mdash; Daizen Ikehara shared strategies for building **scalable and secure SaaS apps** tailored for the Japanese developer ecosystem.
* **Infobip Shift** – Carla Urrea spoke about “Securing AI: A Journey Through Access Control Systems.”
![Infobip Shift](https://images.ctfassets.net/23aumh6u8s0i/5vokh8jDIdVDFU3eWwOAnc/f6758558c0803cbe33a56b46c1e0eebf/events01.jpg)
* **API Days New York** – Ramona Schwering talked about AI and security
* **Dublin Tech Summit** – Deepu Sasidharan talked about how OAuth and OpenFGA Can Keep Your AI Agents from Going Rogue!
![Dublin Tech Summit](https://images.ctfassets.net/23aumh6u8s0i/2aQY44SfC8hnCSQ5WADHhu/df2e04f745af6552b1b7df3476df846e/events02.jpg)

### Where we’ll be in June

June is shaping up to be a big month for developer events, and we’re showing up in full force across frontend, AI, open source, and cloud communities. If you’re attending any of these, come say hi, catch a talk, or grab some Auth0 swag!

**dev_day(25)** (June 18th) - dev_day(25): Auth for Agents is a one-day, free, virtual crash course on auth for AI agents and humans with Auth0. [RSVP](https://developerday.com/rsvp) today to join us on June 18th.

* **Frontend Nation 2025** (June 3rd) – Ramona Schwering will share tips on building secure, user-friendly frontends.
* **AI Engineering World's Fair** (June 3rd) – Exploring the future of AI-powered software and secure identity in agent workflows.
* **AWS Summit Hamburg** (June 5th) – Juan Cruz Martinez joins to discuss secure multi-tenant patterns for AWS builders.
* **RenderATL** (June 11th) – Ramona Schwering and Jessica Quick will be alongside Netlify at the booth, while Shawn Meyer will be on a panel on AI.
* **React Summit** (June 13th) - Ramona returns to the stage with a developer-first approach to modern identity in React apps.
* **VLCTechFest** (June 14th) - Carla Urrea joins the dev community in Valencia to connect on open source and identity.
* **Open Source Summit North America** (June 23rd) - Carla shares insights on securing community-led software.
* **AWS Summit Japan** (June 25th) - Daizen Ikehara will present best practices for large-scale identity in the public cloud.
* **Vercel Ship** (June 25th) - Juan Cruz Martinez will be on-site with a spotlight on edge-first auth patterns for AI apps.

Planning to attend? Reach out! We’d love to meet you and hear what you’re building.

Expect talks, demos, and plenty of real-world tips on building secure, AI-aware, and scalable identity experiences.

That’s it for May! We’ll be back next month with more dev-first updates.

Until then:

Stay secure. 
Keep shipping. 
We’re here if you need us.

May 2025 in Auth0: Async Auth, Real-Time Streams, and Custom Everything

jorge-fatta

Jorge is a Software Engineer that enjoys building tools for colleagues. He manages the Developer Tools team at Auth0. This team works on improving development workflow through tools and automation. He likes to spend time with family, playing football, or preparing and drinking all possible forms of coffee.

Engineering Manager

Jorge Fatta

Helping engineers stay focused on building features that solve the hard problems of identity for customers.

Auth0 is continuously growing. To share a couple of examples, we just hit a new milestone: [_2.5B+ monthly logins securely authenticated_](https://twitter.com/auth0/status/1101216297206059009) and we [_ended 2018 with a nearly 80 percent increase in both sales and new customers_](https://auth0.com/blog/auth0-closes-year-of-impressive-growth-in-2018/).


We are growing and scaling the organization at a really fast pace, and engineering is no exception. This presents some interesting and fun challenges:

1. Promoting and developing the **culture** that fuels this endeavor.
2. **Hiring** and retaining great engineers.
3. Minimizing duplicate work and time to be **productive** as new people come in.

This blog post is focused on how Auth0 is addressing part of that last challenge; by building a dedicated team to unleash the potential in Auth0 developers to deliver business value with confidence.

## Developer Tools Team at Auth0

In the same way that Auth0's goal is to make identity simple for developers, the Developer Tools team goal is to let our engineers fully focus on development and providing value for our customers. We want to provide the best tools to keep our developers happy and engaged shipping new features instead of struggling every day with exhausting and repetitive tasks that could be automated.

We defined the mindset we want to adopt to develop our tools and outlined a roadmap with the following vision:

> Provide toolchains that Auth0 engineering teams can use to improve their workflow, automate manual tasks, simplify complex processes, and implement a set of company-wide standards.

### What we do

1. Work closely with the engineering teams to understand their pain points, provide tools and guidance.
2. Investigate existing tools and develop new ones to solve their needs:

 * Development Environment tools.
 * Change Management tools.
 * Debugging and Performance tools.
 * Incident Response tools.
 * Work with the [_SRE team_](https://auth0.com/blog/progressive-service-architecture-at-auth0/) to integrate site reliability tools into the platform.

1. Recommended patterns & practices:

 * Identify patterns currently in use across our organization.
 * Provide developer tools for Scaffolding and Code Snippets.
 * Promote the adoption and tooling for the best engineering practices, e.g.: [_contract testing_](https://martinfowler.com/bliki/ContractTest.html).

### What we don’t do

1. While we provide general guidance, we don’t do consultancy, i.e.: we neither do work at a particular team's requests to tackle specific issues, provide advice on demand, or do an investigation by request nor develop customized solutions to solve a specific team's needs.
2. We don’t provide advice or work on particular issues on demand: our tools are developed following a *product* approach.
3. We don’t embed team members on another team to build tooling. We might do it for discovery, but development happens within the Development Tools team.
4. We don’t debug and profile internal services, we provide the toolchain for that.
5. We don’t do [_SRE (Site Reliability Engineering)_](https://auth0.com/blog/progressive-service-architecture-at-auth0/), we might provide tooling that could improve the experience during their analysis.
6. We don’t investigate a random tool or technology on demand. We do it if it is related to reducing developer pain.

<include src="TweetQuote" quoteText="Learn how our engineers stay focused on solving the hard problems of identity for our customers."/>

## Tools Development Mindset

We are approaching the development of the tools as internal **products**, guided by these principles:

1. **Ownership**: We own the tools that we ship, following a “*You Build It, You Run It*” principle.

 * We operate what we build: taking care of the CI/CD, incident response, etc.
 * We take care of not just the coding but also keeping the *product* running in good shape.

1. **Extensibility**: We develop these tools taking extensibility into account from scratch.

 * For example, any engineer should be able to easily extend* *the* CLI *that we provide to interact with Auth0’s local development environment.

1. **Internal Collaboration**: We engage our users to **contribute** with the tool evolution, collecting their feedback and welcoming their contributions to the code and documentation (via pull requests on git repositories).

We aim to follow an **iterative** process to develop our tools (just like our Product Engineering teams), working closely with our internal customers.


> The process adopted by our team suits the lean startup cycle model.

->![Jeff Patton & Associates: lean startup cycle model](https://images.ctfassets.net/23aumh6u8s0i/4TRZnZXwjpgNp5gtf4u168/b8ab189eea4a634cdbadfcf67b5c12be/lean-startup-model)<-

*[*_Lean Startup Model_*](https://www.jpattonassociates.com/common-agile-int-for-startups/lean-startup-model/)* by *[*_Jeff Patton_*](https://www.jpattonassociates.com/) is licensed under [CC BY 2.0](https://creativecommons.org/licenses/by/2.0/).*

<include src="TweetQuote" quoteText="The Auth0 Developer Tools team shares three key principles to develop a tools-development mindset that helped them create successful internal products for developers."/>

## Our Tools

Some of the tools that we currently maintain and regularly work on had a great impact and adoption rates within the organization but were built prior to adopting the _internal dev tools as product_ mindset mentioned above. It was originally hard for us to *learn *from the tools once released without any kind of usage metrics. For that reason, we focused on existing solutions by:

* Improving **documentation**, both user guides and internal playbooks concisely describing deployment, troubleshooting, and **contribution** guidelines.
* Instrumenting **usage and performance** metrics to **measure** the impact of our iterative improvements.

### Vivaldi

->![Containers on a dock](https://images.ctfassets.net/23aumh6u8s0i/5d1b2HI9Jjwld4HEksBQff/ec3bdb6bf8883d78cf39f907bb6f65bf/containers-on-a-dock)<-

*Photo by *[*_Guillaume Bolduc_*](https://unsplash.com/photos/uBe2mknURG4)* on *[*_Unsplash_*](https://unsplash.com/)*.*


**Vivaldi** is the tool on which we have invested most of our efforts so far. Named after the Italian musical composer, it is a [_Docker_](https://www.docker.com/) container-based development environment that allows engineers to run a local Auth0 on their machine.
Through a command line interface (CLI), Vivaldi provides commands to quickly interact with our service instances running locally in order to:

* Update dependencies.
* Run tests.
* Attach a debugger.
* Run diagnosis tools.
* Execute performance profilers.

->![Vivaldi: Docker container-based development environment](https://images.ctfassets.net/23aumh6u8s0i/1NlLXfq8I0vpBm5KL3cI5l/30cd621072a76bcd0406151786f49246/vivaldi)<-

The initial version of the tool had a **great impact on the development cycle** and was **widely adopted**. Before *Vivaldi*, developers needed to manually spin up the services they were working on, fighting with dependencies with their local environment. Now they can rely on an isolated and replicable environment, being able to spin up the entire services cluster relatively quickly.

As our teams and number of services grow, we are now actively working with teams to better implement a fast development loop without relying too much on running all Auth0 services locally. We are already planning the next generation of Vivaldi, which will support future growth in a scalable way.

### Slack Bots

->![Droid giving you a helping hand](https://images.ctfassets.net/23aumh6u8s0i/H5W70I4X8Ot6NSsj0VHyv/fadc300cf5495e31413a4ef43f2128d7/droid-giving-you-a-helping-hand)<-

*Photo by *[*_Franck V._*](https://unsplash.com/photos/jIBMSMs4_kA)* on *[*_Unsplash_*](https://unsplash.com/)*.*

We developed an internal Slack bot platform called _Gynoid_ during a hackathon and it was quickly adopted by our engineering organization. The platform is customized to satisfy the needs of our developers:

* To build Slack bots easily: just create a JavaScript file, add metadata, and you are done!.
* To install Slack bots straight from a GitHub repository.
* To extend existing bots from different sources: one bot, multiple functions, different repositories.
 * We call these extensions Droids. To install new extensions, we have a Gynoid that serves as a wrapper for this library. Our _Gynoid Droid_ is responsible for registering and extending our bots directly from Slack.

A notable Droid is one that serves as a _concierge_ for any Slack channel, properly named @concierge. It works like this:

* A channel that needs a person on duty to address direct questions invites `@concierge` to the channel.

->![Inviting the concierge Slack bot to a channel](https://images.ctfassets.net/23aumh6u8s0i/762YoyCbXhOlyM9zQAr24/469fe557035293e641012aa2bc03c672/invite-concierge-slack-bot)<-

* A teammate is assigned the role of `@concierge`.

->![Assigning the concierge role to a teammate](https://images.ctfassets.net/23aumh6u8s0i/2u1bJjRFdCbJWf48k9t1Ot/3fb1c5c67e6d6819df21f09564896e18/assign-concierge-slack-bot)<-


* When someone needs to ask anything to a team, for example, they visit the team's channel and ask the question directly to `@concierge`.

->![Asking a question to Slack bot concierge](https://images.ctfassets.net/23aumh6u8s0i/3Gtm4wdoomqbMJas4rzjGf/a1249a2842972eae97cc08b29328a28d/asking-question-concierge)<-

* The teammate with the role of `@concierge` is sent a direct message through Slackbot with the concierge request.

->![Slack bot concierge sending a direct message to teammate](https://images.ctfassets.net/23aumh6u8s0i/4nPgWa3KasUha1YjLcAmos/641263ac54adb338d5906ee7d410673b/concierge-slack-bot-direct-message)<-

* The concierge has now the responsibility to research and to address the request directly. If the request is outside of the scope of the team, the request is redirected to the appropriate channel

The concierge droid helps us avoid unnecessary noise in Slack &mdash; especially since it is widely used within our company as a good substitute for `@here` and `@channel` when asking questions. It's very useful when you have an "on-call" rotation in your team and people need to reach the teammate on call through a Slack channel.

## Roadmap

We are currently working on the next major version of our main tools, focusing on:

* **Scalability improvements**: Vivaldi, our Docker-based development environment, will run an increasing number of services without compromising the developer machine resources.
* **Robustness**: Gynoid, our slack bots platform, will have end-to-end tests and its dependencies will be upgraded to the latest stable versions, allowing our team and contributors from other teams to introduce changes or develop new *droids* with confidence.

Additionally, we’re in the early stages (discovery, viability analysis, and ideation) for a **unified internal CLI** (command-line interface): we already have multiple CLIs that provide different types of functionality. As the number of CLIs keeps growing, it will become hard to keep track of them.

Some teams will decide to use a different tech stack, which may require different runtime dependencies and a distinct CLI to better manage it. However, we could create a unified CLI, customizable and extensible to meet the needs of different tech stacks. Having a unified CLI will help internal toolchains scale while staying maintainable.

## Conclusion

We aim to provide an optimal developer experience, unified across the engineering organization. To do this we take ownership of the toolchains, iterate to improve them and encourage teams to use these tools that have already proven their value on making developers more productive.

We dedicate our Developer Tools team efforts to the discovery, building, maintenance, and promotion of reusable solutions so that the rest of the engineers don’t have to struggle with repetitive tasks, walk through slow development cycles, or constantly switch contexts to take care of maintenance tasks that can be automated.

We want Auth0 engineers to be focused on building new features that solve the hard problems of identity for our customers.

<include src="asides/AboutAuth0" />

"developer-tools"