As a technical writer, my job is to explain complex things simply. It’s what I do. 

But what happens when the architecture of a powerful idea is inherently complex?

It calls for the right tools to magically abstract that complexity, making it simple to understand and implement.

This was the challenge I faced with an advanced project that I’m incredibly passionate about: the Automated Portfolio Manager. 

It’s a fully onchain investment portfolio that anyone can invest in, designed to manage a basket of any assets—from cryptocurrencies to tokenized real-world assets. The magic lies in its dynamic rebalancing: it automatically adjusts its own holdings based on real-time offchain market data, such as crypto sentiment scores and gold volatility indexes.

Simple goal. Complex to do. Because building that is building a truly ‘smart’ portfolio.

I had built and documented this exact project in 2024 using the existing Chainlink stack. 

It worked, but the developer experience was a beast. It required stitching together multiple services, managing different subscriptions, and scattering the core logic across different services and runtimes.

This year, I rebuilt it with the Chainlink Runtime Environment (CRE). Even using the beta, the difference was staggering. 

What once took a week to build and even longer to document, now takes just three hours. The complex workflow had become easy to build.

The Challenge: A Symptom of Evolving Complexity

To understand the impact of CRE, you first need to see what life was like before. Here is the architecture of the original Automated Portfolio Manager:

Now, it’s important to say that this architecture wasn’t bad—far from it. It was a powerful and creative solution that used state-of-the-art tools at the time to solve a real problem.

In fact, it perfectly illustrates the evolution of Web3 itself. The definition of a ‘smart contract’ has expanded beyond a single piece of code on one chain. Today’s applications require orchestrating onchain logic with multiple offchain services, offchain and onchain data, data feeds, and cross-chain systems—all working in concert.

Beyond coding, this takes system design skills.

My ‘Rube Goldberg machine’ wasn’t a sign of poor design; it was a reflection of real-world, advanced Web3 usage. The pain points were a direct result of pushing the existing, powerful tools to meet this new demand for orchestration:

• Fragmented Services: To combine offchain data with onchain logic, I needed to manually stitch together Chainlink Functions and Chainlink Automation using custom logic and preset time intervals.
• Scattered Logic: To modularize and manage an expanding system, I had to split the code across Solidity and JavaScript and then connect them.
• High User Overhead: To make it robust, data-driven, and data-responsive in a pre-orchestration world, I needed to bootstrap a complex setup process.

This is precisely where the need for a true orchestration layer becomes critical. When a system reaches a certain level of complexity, you need a control plane to manage it all reliably and verifiably. 

This is the problem CRE was created to solve.

The Solution: A Single, Unified Workflow With CRE

Then came CRE—a paradigm shift from connecting Chainlink services to composing Chainlink services.

I took that complex beast and turned it into this:

All that complexity is just… gone. Or rather, abstracted away so you don’t have to deal with implementation details and can focus on composing the outcomes you want.

So, what is CRE?

Think of the Chainlink Runtime Environment as a master conductor for your decentralized application. 

Instead of you having to manage a scattered orchestra of services, CRE provides a single environment where you can write one unified composition that handles everything. This seamless orchestration is the key.

With CRE, the entire end-to-end logic for the Automated Portfolio Manager now lives in a single Go file and a much simpler, single smart contract. Here’s the sequence of steps (called “capabilities” in CRE):

• A CRON trigger initiates the workflow on a schedule.
• The HTTP capability fetches real-time offchain data.
• The workflow logic performs all the rebalancing calculations.
• The EVM capability packages the results and sends a single transaction to the smart contract.

This unified approach, powered by CRE’s modular capabilities, enables a massive leap in developer experience. What took me a week to build before was now rebuilt in just three hours.

A Fundamental Shift in Building for Web3

This isn’t just about a better developer experience; it’s a fundamental shift in how we build decentralized applications. When you dramatically reduce complexity, you accelerate the pace of innovation. Ideas that were once too impractical to build due to architectural overhead are now within reach for developers.

CRE represents the next evolution of Chainlink’s mission to unlock innovation with blockchains. It moves beyond providing the individual building blocks of data and services to providing the entire factory for building with them. It’s the engine that will power the next generation of verifiably-run applications, and I’m incredibly excited to see what builders do with this new superpower.

If you are an institution, protocol, or developer interested in testing how to leverage CRE for your use case, click here to join the early access program.