Welcome to the Architecture Corner.
Great to be here. Today we're looking at some
really interesting significant updates coming to AWS Step
Functions in 2025. Yeah, the G Sonata support and
the new IO processing model big changes.
Exactly. Mario Bittencourt flagged these
recently. Our goal today is really to
explore how these innovations might streamline low code
development for you, making those complex workflows, well,
hopefully more powerful and easier to manage.
I think foundational shift isn't too strong a term here.
You can really change how we approach designing these state
machines. OK, foundational shift.
I like that. So before these updates, working
with step functions using the Amazon states language ASL, it
often felt a bit complex. What were the main hurdles you
saw people running into? Yeah, complex is putting it
mildly sometimes. There was definitely a steep
learning curve, mostly because all those different O fields,
Yeah, input path, output path parameters, result selector,
result path, just figuring out which one did what and when to
use. It that could be confusing.
It really could, and the bigger issue maybe was if you needed
data from way back at the start of your workflow, like several
steps later. Oh yeah, the pass through
problem. Exactly.
You have to manually thread that piece of data through every
single intermediate step. It made the state definitions
messy and honestly pretty brittle.
Like playing telephone with your critical data.
Lots of boilerplate just to keep info alive.
OK, so it sounds like these new updates directly tackle those
pain points. What are the key improvements?
So 2 main things. First up, variables.
Think of them like little temporary storage spots right
inside your workflow execution. OK, you can save data, change
it, refer back to it later without having to pass it output
to input between states. They have a clear scope get
updated when the state finishes. And they can hold a decent
amount of data. Yeah, up to 256 KD each and you
get a total of 10mm for the whole execution.
That's pretty generous. It might mean you don't need to
use, say, S3 quite as often just to shuttle larger payloads
around internal. That alone sounds like a huge
win for cleaner workflows and managing state less plumbing.
It really is less plumbing, less cognitive load, trying to track
where data is is coming from and going to.
Which brings us nicely to the second big thing, simplified IO.
OK, basically they've taken that confusing list of five IO fields
and boiled it down to just two concepts.
You've got arguments for the data you feed into a task,
right? And output for the date of the
state makes available when it's done.
That's it. Much simpler mental.
Model arguments in output out. OK, that definitely sounds more
intuitive. So cleaner data flow, simpler
IO. But the big promise is often
about less custom code, right? How does Jason Outta fit into
this? Yeah, Jason, Audi S kind of the
engine driving these new capabilities.
It's a query and translation language specifically for Jason.
OK, I've heard of it, but how does it work here?
Well, it's the syntax you use now for defining those arguments
and output fields, and also for manipulating the new variables.
And the cool thing is, Jon is a pretty powerful.
O you can do logic inside the step function definition itself.
Exactly. You could do things like filter
arrays, maybe pull out only the orders marked fragile from a
list. Or you could calculate a sum
like the total value of items in an order, even generate hashes.
Without needing a Lambda function.
Often, yes. For those kinds of data
manipulation tasks that previously might have required a
dedicated little Lambda function, you might now be able
to do it directly within the step function state definition
using J Sonata. Wow, OK, so that could genuinely
mean fewer moving parts, simpler deployments for certain logic.
Potentially yes, less code to write, deploy and manage
separately. But like with any powerful tool,
there are trade off to consider. It's not all smooth sailing.
Always the case. What should people be thinking
about as they start using this? What are the potential
downsides? Well, two main things jump out.
First, you could end up fragmenting your logic if you
have some business rules in Jonata within your ASL and other
related logic in say a Lambda function called by another
state. Right, it could get harder to
see the whole picture. Exactly.
Really complex Jason at Expressions embedded directly in
the workflow definition might actually be harder to understand
and debug than straightforward code in an IDE.
Hmm, OK, maintainability could suffer if you go too complex
with the embedded logic. What's the second point?
The second is around automated testing.
The tooling and frameworks for automatically testing complex
JSON on expressions, especially within the context of a step
function state, aren't as mature as what we have for standard
code like Python or Node JS and a Lambda.
So you might need more manual testing or find it harder to get
the same level of confidence for really critical transformations.
You might, yeah. It's something to be aware of,
especially for logic that has significant business impact.
You need to plan your testing strategy carefully.
Makes sense. So clarity and testability are
key things to watch. But overall the benefits seem
pretty clear. Potentially less code, maybe
faster delivery, lower operational overhead in some
cases. Absolutely.
I think the winning approach is going to be a balanced 1.
Using variables in the simplified IO seems like a clear
win almost everywhere. It just cleans things up.
Yeah, that feels like a no brainer.
Right. The more strategic part is
deciding how much logic to push into play Sonata versus keeping
it in dedicated compute like Lambda.
That depends entirely on your specific needs, the complexity
involved in your team's comfort level.
So use the simple stuff widely. Be thoughtful about the advanced
Jon auto transformations. It's about finding that sweet
spot for your context. Precisely.
OK, this has been really insightful.
Remember, you can check the description For more information
on these updates and a reminder to subscribe for free to the
Architecture Corner newsletter over at
architecturecorner.substack.com. Definitely worth digging into
the specifics of this impacts your workflows.
For sure. It leaves me wondering, though,
as we get these powerful locode tools, how do we ensure we're
not just optimizing for initial speed, but also for that crucial
long-term clarity and maintainability?
That balance feels key.