Many thanks. I knew there must be some way to keep that “state” without using a GenServer. My first issue had actually been figuring out how to use the left node value as the tally for the grandparent node calculation. I only figured that out after changing to GenServer which made the steps in the process clearer to me. Changing to returning tuples was trivial. Thanks again.

  def convert_bst(root) do
    do_convert(root, 0) |> elem(0)
  end
 
  def do_convert(nil, tally), do: {nil, tally}
  def do_convert(node, tally) do
    {right, interim_tally} = do_convert(node.right, tally)
    new_val = interim_tally + node.val
    {left, final_tally} = do_convert(node.left, new_val)
    {%TreeNode{ val: new_val, left: left, right: right}, final_tally}
  end

I came up with a similar solution, and it passed the tests:

defmodule Solution do
  @spec convert_bst(root :: TreeNode.t | nil) :: TreeNode.t | nil  
  def convert_bst(root) do
    {converted, _} = do_convert_bst(root, 0)
    converted
  end
    
  defp do_convert_bst(nil, _carry), do: {nil, 0}
  defp do_convert_bst(node, carry) do
    {right, sum_r} = do_convert_bst(node.right, carry)
    carry = carry + node.val + sum_r
    {left, sum_l} = do_convert_bst(node.left, carry)
    {%TreeNode{left: left, right: right, val: carry}, node.val + sum_l + sum_r}
  end
end

carry is the sum of the values of all the nodes that have already been visited that have values greater than the next node to visit.

I have no ideia how to implement such algorithm, but!
Genservers are an abstraction over a looping receiver, so you can try to implement it with recursion, keeping the state as a parameter and keep passing it. Start with the base cases that returns a value instead of recusing. I bet it will look closely to your current implementation,but without the genserver specifics