Blockchain Software Development Outsourcing: Avoiding Vendor Lock-In

A Handy Guide for Startup and Enterprise Teams to Outsource Blockchain Development

Outsourcing blockchain development can really transform the game. This playbook is here to help you navigate things smoothly while keeping a solid handle on the code, infrastructure, and roadmap over the long haul. Here’s the scoop you need to make smart choices.

Understand Your Needs

Before you jump into outsourcing, it’s a good idea to pause for a moment and really consider what you actually need. Ask yourself:.

What particular blockchain development tasks do I feel like outsourcing? What skills or know-how are we missing in our team?
How does this tie into what we’re trying to achieve with our project?

Find the Right Partner

Picking the right outsourcing partner can really be a game changer for your project. It can either set you up for success or lead to some serious headaches! To make things a bit easier, here are some handy tips to think about:

Check Out Potential Vendors: Do some digging to find companies that have a proven history with blockchain projects.
Look at Reviews and Case Studies: Check out how they've made a difference for people in situations like yours.
Get Those References: Feel free to connect with past clients for their thoughts and experiences. It can really give you some valuable insights!

Maintain Control

Staying in control is super important, even when you’re handing things off to someone else. Here are a few tips to help you stay organized and keep everything in check:

Set Clear Goals: Right from the start, it’s important to lay down some solid goals and expectations. This way, everyone knows what they’re aiming for!
Stay in Touch: Make it a habit to have regular catch-ups and meetings so you can keep an eye on how things are going.
Keep Everything Documented: Make sure you have a good system in place to note down all the changes and decisions. It's super helpful to reference later!

Protect Your Intellectual Property

Your code and ideas are truly awesome! To protect your intellectual property, think about taking these steps:

Non-Disclosure Agreements (NDAs): Make sure your partners sign an NDA to keep your sensitive info under wraps. It's a smart move to protect what matters most.
Code Ownership Clauses: Be sure to include in your contracts that you have full ownership of the final code and any variations of it. It’s super important to clarify this upfront!

Create a Feedback Loop

Make sure to seek feedback regularly and right from the start. It's a great way to catch any issues before they become bigger problems. Plus, getting input from others can really help you improve along the way! This way, you can tackle any problems before they get too big to handle. Consider these strategies:.

Regular Check-ins: Make it a point to have some catch-up sessions to see how things are going with the work.
Get Users Involved Early: Bring in real users from the get-go to get their take on how things work and how easy they are to use.

Plan for the Future

Finally, think long-term. As your project grows and changes, it’s important to keep the code and infrastructure flexible. You want them to be able to adapt as things develop. Here are some tips:.

Flexible Architectures: Make sure your systems are built in a way that they can adapt and expand as your needs change. Keeping things modular will help a lot!
Get Ready for Success: Make sure your outsourcing partner hooks you up with the right tools and documentation so that everything transitions smoothly.

If you stick to these tips, you can totally outsource your blockchain development and still keep a handle on the key parts of your project. Happy outsourcing!.

Why “lock‑in” is a bigger risk in blockchain than in web2

Unlike traditional SaaS, a blockchain solution can really lock you in at several levels all at once.

So, when it comes to smart contracts, they often get tangled up in these tricky proxy patterns that aren’t really portable. Plus, the whole ownership situation can be pretty murky, and sometimes you’re dealing with bytecode that hasn’t been verified. It’s definitely a bit of a mess!

L2 stacks: Just a heads up, you could run into some ongoing fees or have to jump through a few hoops for approvals. This might be due to things like incentives, licenses, or governance matters.
Data Availability (DA): You can link rollup expenses and the whole data lifecycle to a single DA layer.
Key Management: Just a heads up, if you're not careful, you might find yourself in a situation where upgrade keys or your treasury are all controlled by one vendor. This could be anything from a custodian to an MPC provider or even some sort of exclusive tools. It's worth keeping an eye on!
RPC and infrastructure: It’s pretty risky to put all your eggs in one basket by depending on a single provider. If they go down or tweak their APIs, you could end up facing some serious issues.
Cross-chain: Relying on specific bridges or APIs can really hold you back when it comes to smoothly interacting with various platforms.

Just one tiny hiccup can really mess up your product. Let’s rewind to November 2020 for a moment. Remember when Infura had that outage? It all happened because some Geth clients hadn’t been patched, which led to a brief splinter in the Ethereum network. It was quite the situation! So, this glitch really threw a wrench in a bunch of apps, and as a result, exchanges and wallets had to hit pause until they got everything sorted out. This was a classic example of a consensus or client issue that got out of hand because there was too much dependence on centralized infrastructure. It's definitely the kind of systemic coupling we should avoid at all costs. (coindesk.com).

A vendor‑neutral risk map you can audit in a day

Use This Checklist to Grade Your Current (or Proposed) Outsourcing Partner:

Experience and Expertise: Does your partner have a proven history in your industry?
Client References: Can they share any testimonials or case studies from happy clients with you?
Quality of Work: Do they have a reputation for consistently delivering top-notch results?
Communication Skills: How good are they at getting their point across? Do they respond promptly and clearly?
Cultural Fit: Are their values and work habits in sync with what you believe in?
Pricing Structure: Do they have clear and fair pricing for what they're offering?
Scalability: Are they able to adjust their services easily if your business needs shift?
Technology and Tools: Are they using the latest tech and tools that actually fit what you’re looking for?
Risk Management: So, how do they deal with any risks or challenges that pop up?
Legal Compliance: Do they follow all the necessary laws and regulations?
Support and Maintenance: So, what kind of ongoing support can you expect from them after you've kicked things off?

Don’t rush it! Take a moment to really think about each point. Being honest in your evaluation will help you make a smart choice for teaming up.

1) Contracts and Upgrade Control

Hey there! Just wanted to share that we’ve got the proxy pattern all ready to go and it’s fully documented--plus, it’s open-source, which is pretty cool! You’ve got the option to pick between UUPS or Transparent, and we’ve even included storage layout checks in the CI. Exciting stuff! Also, upgrades are secured with a timelock and a multi-signature setup through a DAO. Check it out here.

So, when we're thinking about modularity, we're looking at two options. One is going with ERC-1967/UUPS, which has clear facet boundaries. The other option on the table is Diamonds (ERC-2535). Both have their perks, and we're weighing what fits best! This way, we can totally get past that annoying 24KB limit. More info here.

We're really simplifying our verification process by automatically publishing everything to Sourcify, not just sticking to the explorer UI. It’s going to make things a lot easier! So, what this really means is that our code is super flexible and can be checked by machines on various chains. Get the details here.

2) L2 Stack and Licensing

About those license terms: you won’t have to worry about getting stuck with revenue sharing or jumping through approval hoops. Make sure to check out the actual repo license instead of just skimming through the marketing stuff. For example, OP Stack is licensed under the MIT license, while Polygon CDK falls under the AGPL-3 license. Most of the ZK Stack repositories are licensed under either the MIT License or Apache 2.0, which is pretty standard for open-source projects. Just a heads up, APIs usually come with their own set of rules, so make sure to check those out too! Take a look at this: github.com. It’s pretty cool!
Don't forget to keep an eye on the economic hooks, too! They can really catch you off guard. Let’s talk about Arbitrum Orbit for a second. It’s backed by these custom gas tokens, which is pretty cool. They've even mentioned things like revenue sharing or fees in certain situations. It's definitely worth keeping an eye on! Just a heads-up: it's a good idea to figure out how to opt out or plan for these costs beforehand. It'll save you a lot of stress later on! If you’re curious and want to dig deeper into the details, check this out: theblock.co. It's a great resource!

3) Data Availability and Fees

Hey there! Considering a change to your DA layers? Well, you might want to check out EIP-4844. It’s made quite a splash by introducing blobspace on Ethereum, which has actually helped reduce those rollup DA costs. This update was shared on March 13, 2024, during the Dencun event. Pretty cool, right? Also, there's this awesome design for "alt-DA" like Celestia Blobstream. The best part? You won't have to worry about being hit with fees and those annoying retention windows! Take a look at this link: (datawallet.com). It's got some really cool info you'll want to check out!

4) Keys and Wallets

It's a good idea to avoid putting all your eggs in one basket when it comes to custody with a single vendor. You might want to check out open MPC libraries, or consider using multi-signature setups paired with timelocks. Those options can really give you some solid security! If you’re getting into Account Abstraction (ERC-4337), it’s a good idea to look for multi-bundler support. And do yourself a favor--steer clear of any vendor-specific EntryPoint forks. Trust me, it’ll save you some headaches down the line! Take a look at it on GitHub! You might find something interesting there!

5) Infra and RPC

You can set up multi-home RPC directly in the SDK by using either the ethers FallbackProvider or the viem fallback transport. It's pretty straightforward! Just choose the one that fits your needs best and get started. These days, it’s not just about flipping endpoints by hand anymore. Don't forget to keep an eye on your own nodes as well! Take a look at the details over at this link: docs.ethers.org. You might find exactly what you need!

Cross-chain and Identity
You know, it’s definitely smart to stick with chain-agnostic standards like CAIP-2/10. Plus, using open protocols like IBC/ICS-20 or Polkadot's XCM can really pay off. It's all about keeping things flexible and open, right? With this approach, you can totally avoid those proprietary bridges. If you want to dive deeper into this topic, definitely take a look at chainagnostic.org. It’s got some great info!

Contract architecture patterns that keep you portable

Pick upgrade paths that you can switch over. Hey there! So, when it comes to choosing between UUPS (EIP‑1822/1967) and Transparent proxies, just make sure you jot down which one you decide to go with. Also, don't forget to check the storage layout compatibility in your CI using the OpenZeppelin Upgrades Plugins for either Hardhat or Foundry. It's a small step, but it makes a big difference! Hey, just a quick reminder to make sure you set up the upgrade authorization in _authorizeUpgrade. And don’t forget to keep your ProxyAdmin ownership tidy--it's best not to reuse any ProxyAdmin contracts from before version 5. x). (docs.openzeppelin.com).
Include some extra time and make it visible to the community. Hey, have you thought about putting your upgrade authority behind a TimelockController? It could be a smart move! Let's give the governor the exclusive power to suggest changes and set the executor to a zero address. This way, anyone can step in to carry out the proposals. With this setup, your users can easily exit if they want to, and you also get the flexibility to change signers without needing to hit pause on your app. It's a win-win! (docs.openzeppelin.com).
When it comes to big products, think about designing for “facet swap.” Using ERC-2535 Diamonds can seriously change the game! This cool feature allows you to add new functionalities without getting stuck with that 24KB limit. Plus, you can easily swap out facets without needing to change the address that most integrators are using. Pretty neat, right? It helps keep everything tidy for long-lasting platforms, which means you won’t have to worry about migrating as often. (eips.ethereum.org).
Turn verification into an automatic and decentralized process.
Once you're ready to deploy, just shoot your source code and metadata over to Sourcify. It takes care of full verification by using the compiler metadata, and it stores the artifacts in an open repository. Honestly, this makes things so much simpler than relying on just a single explorer UI. (github.com).

L2 stack selection: licensing, governance, and exit ramps

OP Stack (Optimism)
License: The main repo uses the MIT license, which is pretty straightforward. As for OP Labs, they believe in keeping things simple with "no contracts or licenses" when it comes to launching a chain. It's a clever approach to avoid getting tied down by commercial constraints. They’ve added op-alt-da, which gives you the flexibility to dive into various DA backends. By the way, fault proofs officially launched on the OP Mainnet on June 10, 2024, which is exciting because it means we're at “Stage 1” when it comes to decentralization. A ton of OP Stack chains are really stepping up their game lately! (github.com).
Arbitrum Orbit
The feature updates are coming out fast, kind of like those custom gas tokens. But hey, it’s definitely smart to take a moment and consider the economic side of things. Hey everyone! I've noticed there's been quite a bit of buzz around Orbit's license fees and how revenue sharing works in various situations. Just a heads-up to take a look at the latest terms for your setup! Oh, and just a heads up, BoLD, which lets you create permissionless fraud proofs, officially launched for both Arbitrum One and Nova on February 12, 2025. This is great news for validators because it means they won't have to deal with as much lock-in time! (theblock.co).
Polygon CDK
License: AGPL‑3. 0 (copyleft). This tech is really cool, but just a heads up--those copyleft rules might affect how you go about packaging or tweaking any of the closed components. It’s a smart move to touch base with your legal team right from the get-go. Hey! Just a heads up, Polygon has released their Type-1 zkEVM prover as open source. It’s available under a dual MIT/Apache 2 license, which is pretty cool! 0), which really simplifies things for certain stacks. Take a look at this: GitHub link. Trust me, it’s worth a peek!
ZK Stack (zkSync)
Most of the main repositories are licensed under MIT or Apache 2.0. You won’t find any licenses here, but you might come across some GPL components, like that forked Solidity compiler. Hey, if you're thinking about using hosted nodes, don't forget to look over the separate API terms. It’s definitely worth your time! Sure, you can fork and self-host with this setup, but make sure to really check out the license for each subrepo. Don’t just assume you have free reign across the board! (github.com).

Don't forget about governance safety valves--they're super important, too! Many Layer 2 solutions have Security Councils that are equipped with emergency powers. So, it's really important to be aware of who’s in charge of making decisions like pausing, upgrading, or even rolling back certain features. It's important to have public charters, easy-to-follow election processes, and some established thresholds. These things help keep everything transparent and fair! Take Arbitrum, for instance. They’ve got this council with 12 members, and if there’s an emergency, they need at least 9 of them to vote in favor. On the other hand, Optimism has been pretty transparent, putting their Security Council budget and guidelines out there for everyone to see. Hey, just a friendly reminder to make sure you add in your runbooks what the plan is if the council opts to use those powers. It's super important to have that covered! (docs.arbitrum.foundation).

Data availability isn’t just a cost line--it’s a lock‑in axis

Make sure to kick off your design process with multi-DA in mind right from the start. So, once Dencun launches on March 13, 2024, rollups will finally be able to make use of those EIP-4844 "blobs." Exciting times ahead! So, what this means is that you'll notice a decrease in L1 DA costs, which could totally change the way you calculate your fees. Hey, just a quick heads up! Blobs get pruned after roughly 18 days, so you’ll want to make sure your rollup is set up to either re-prove or checkpoint whenever necessary. Keep that in mind! It's really smart to set up your stack in a way that makes it easy to swap out your DA backends. That way, if you ever need to make changes or try something new, you can do it without a ton of hassle. (datawallet.com).

Hey, just a quick reminder to keep the "alt-DA" option in mind. So, here's the scoop: Celestia has this cool feature called Blobstream that allows Ethereum contracts to grab data-root commitments from Celestia. What this means in simple terms is that rollups can actually send their data over to Celestia while still being able to prove that everything's available on Layer 1. Pretty neat, right? If your setup is designed to handle alt-DA--like with the OP Stack's op-alt-da--you'll have the freedom to mix things up without needing to tweak your app's core logic. (docs.celestia.org).

The new shared-sequencer networks are looking really promising when it comes to enhancing resilience. Still, it’s important not to assume they'll stick around forever. A great example is Astria, a shared sequencer built on Celestia. Unfortunately, it had to shut down its network back in December 2025. Make sure your setup is flexible enough to switch back to a local sequencer or try out a different provider without having to totally overhaul everything. It’ll save you a lot of headaches down the road! (unchainedcrypto.com).

RPC and node strategy: multi‑home or you’ll multi‑panic

Implement SDK-level redundancy:
Hey there! If you’re looking to set up a quorum, you can totally make it happen with viem’s fallback transport and ethers’ FallbackProvider. It’s super easy! You can connect with services like Infura, Alchemy, Chainstack, or even your own self-hosted nodes. The options are pretty flexible, so you can pick what works best for you! This way, you can avoid problems that pop up when one provider goes down, plus you’ll reduce the risk of running into outdated information. Check it out here.

Make sure to run at least one of your own nodes for tracking those important paths and keeping an eye on things. It's super helpful! If you're using either geth or Nethermind, you’re in luck! Both of these tools come with Prometheus metrics. This means you can easily monitor important stuff like lag, the number of peers, and how healthy your transaction pool is. It's a great way to stay on top of everything! That's a clever choice! It also lets you take a breather when it comes to those pesky rate-limit changes. If you want to dive deeper, check out this link for more details: here. There's a lot of good stuff waiting for you!

Example (viem fallback):

If you’re trying to keep your app running smoothly, even when things take a turn for the worse, having a fallback strategy can really save the day. Let me give you a quick example of how you could set this up with viem. It’s pretty straightforward!

import { createClient, Client } from 'viem';
import { publicProvider } from 'viem/providers/public';

const client = createClient({
  autoConnect: true,
  publicClient: publicProvider(),
});

// Fallback function to handle errors gracefully
async function fetchData() {
  try {
    const data = await client.someMethod(); // Replace with your actual method
    console.log('Data fetched successfully:', data);
  } catch (error) {
    console.error('Error fetching data:', error);
    // Fallback logic here
    handleFallback();
  }
}

function handleFallback() {
  console.log('Using fallback method to retrieve data...');
  // Implement your fallback logic
}

// Trigger the data fetch
fetchData();

Here's a quick guide on how to set up a client using viem, and I'll also show you how to add a fallback method in case there are any hiccups while fetching data. All you need to do is swap out someMethod with the method you’re actually using to pull your data. Easy peasy! If something goes wrong, it spots the error, logs it, and then switches over to your backup plan. Keep things running smoothly!.

import { createPublicClient, http, fallback } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: fallback([
    http(process.env.ALCHEMY_URL!),
    http(process.env.INFURA_URL!),
    http(process.env.CHAINSTACK_URL!)
  ])
})

viem.sh

Wallets, keys, and AA: portability by design

Hey, just a quick tip: it’s a good idea not to stick all your upgrade or treasury keys with a single custodian.

If you absolutely need to use MPC, it's a good idea to stick with open implementations like tss-lib. Just make sure you’ve got strong contracts in place for exporting and resharing, so everything stays above board! It’s a clever idea to combine this with timelock-controlled governance when it comes to upgrades. Take a look at this: github.com. You might find something interesting over there!

When you're dealing with ERC‑4337 smart accounts, it's best to avoid relying on just one bundler or paymaster.

Go with the standard EntryPoint and ensure you're compatible with various bundlers. It's definitely smart to keep track of how you can switch up paymasters and reduce any dependencies. It's all about staying flexible and avoiding getting tied down, right? You can find the guidelines you need in the spec and community docs. They’ve got all the info to help you out! More info here: (eips.ethereum.org).

Hey there! So, instead of just using random enums, why not take advantage of CAIPs to help you pinpoint accounts and chains? It makes a lot more sense! CAIP‑2 (that’s the chain ID) and CAIP‑10 (the account ID) make it super easy to carry your identities and datasets around from one ecosystem or explorer to another. It's all about keeping things flexible and user-friendly! Dive deeper here: (chainagnostic.org).

Data and NFT metadata: choose content addressing and standards

If you’re working with media files and JSON, definitely consider using IPFS CIDs. They’re super handy for linking and managing your data! They're really useful because they’re content-addressed, which means you can easily move them around between different gateways and pinning services. If you want to dig deeper into it, just click here for more info!

Hey, just a quick reminder to stick to those finalized token metadata standards, like ERC-721 and ERC-1155. It's super important! When you're working with ERC-1155, the ID-substitution URI pattern is super handy! It really helps you avoid those lengthy on-chain strings for each token, making things a lot simpler. If you're looking to dive into dynamic traits, it’s a good idea to stick with clear standards or extensions. Plus, using on-chain events that any indexer can easily recreate will really make your life easier! If you want to dive deeper into it, you can check it out here.

Procurement clauses that actually prevent lock‑in

Don’t forget to include these in your MSA or SOW when you’re working with vendors:

Exit assistance
So, here’s the deal: you’ll want to have your exit plan all set up within 60 to 90 days after kickstarting the contract. And don’t forget, you’ll also need support for at least three months once it wraps up.
This covers things like fixed rates and the knowledge transfer goodies you'll get, such as documents, runbooks, Infrastructure as Code (IaC), and dashboards. Don't forget to include requirements for sharing data in formats that aren't tied to any specific company. (lawinsider.com).
Source code escrow is available, but it’s just for the closed components. Alright, here's the plan: let’s set up an escrow account and make sure we’re giving regular updates along the way. It’s really important to spell out the exact conditions that would lead to a release. Think of things like insolvency, any big breaches, or not hitting those service level agreements (SLAs). Just keeping everyone on the same page, you know? Just a quick reminder to stay on top of keeping your dependencies up to date! It’s super important to avoid any outdated issues down the line. (aaronhall.com).
Access to important materials and admin privileges. Hey there! Just a quick reminder to manage your keys for upgrades, pauses, and treasury according to your organization's HSM or MPC policy. It's super important to have a well-documented process in place for recovery and resharing, so you’re covered in case anything goes wrong. And try to steer clear of vendor-exclusive custody to keep things flexible! If you're working with a vendor that provides HSM or escrow services, it’s super important to clearly outline the rotation and export rights. Make sure you define how often you'll rotate the keys and who gets to export them. This way, everything's crystal clear for everyone involved! (utimaco.com).
Ownership and licensing of intellectual property (IP). You’ll be in charge of any code that’s specific to the app and how we deploy it, but just so you know, any third-party libraries will stick to their open-source licenses. Hey, could you take a quick look at the compatibility of the L2 stack licenses? I’m thinking about how MIT stacks up against AGPL-3. Thanks! 0 obligations). (github.com).

Build and release security: signed, verifiable, reproducible

Hey there! So, if you want to keep your artifacts and images safe and sound, it’s a good idea to set up SLSA-style provenance for them. Don’t forget to use Sigstore cosign to sign everything too! If you can swing it, going keyless would be awesome for added security. Happy coding! This makes it super easy for new vendors to check that they’re using the exact code you’ve reviewed. Hey! If you're curious to learn more, just head over to (slsa.dev) for all the details. It's worth checking out! Hey, just a quick reminder to double-check the contract source on-chain using Sourcify. And don’t forget to validate your container images with cosign in your CI pipeline! It's super important to stay on top of these things. You might want to consider keeping attestation bundles handy with your releases. It’s a smart move! This way, an auditor or even a new vendor can easily rerun checks whenever they need to. If you want to dive deeper, check it out on GitHub.

“No‑lock‑in” reference stack we deploy for clients at 7Block Labs

Contracts: We’re working with UUPS proxies and using OpenZeppelin version 5. So, you've got x, right? And it's paired up with a TimelockController and a few modular interfaces to boot. When we're in a situation where we need a bit more room or some flexibility, that's where Diamonds really shine. Our CI regularly checks out the storage layouts and makes sure everything's good to go for upgrades. (docs.openzeppelin.com).
L2 Stack: We’re diving into the OP Stack (MIT) and have some exciting plans for an alternative DA module that we’re really looking forward to! We’ve got a migration plan in place just in case we need to pivot to Polygon CDK or ZK Stack depending on what the business needs. We're also keeping an eye on the BoLD/FP status for the chains we're focusing on. (github.com).
DA: We're mainly leaning towards using EIP‑4844 blobs, but we're also keeping Celestia in our back pocket as a secondary option via the Blobstream contract route. We're doing some automated fee regression tests to keep our cost modeling on point as blob targets shift around. (datawallet.com).
RPC: So, we’ve got viem’s fallback all set up, and we've also got a self-hosted node for each chain using geth and Nethermind. Cool, right? On top of that, we’re launching Prometheus and Grafana dashboards to keep tabs on everything, including our SLOs. It's all about making sure we have everything under control! (viem.sh).
Wallets/AA: We're rolling out ERC-4337 with multi-bundler routing. Exciting stuff! To keep things secure, we manage our upgrade keys using a multi-sig setup--you can think of it as needing either 2 out of 3 or 3 out of 5 keys to make changes. Plus, we’ve got a timelock in place, so there’s a 24 to 72-hour waiting period before anything goes through.
(docs.erc4337.io).
Keeping Code in Check: We make sure everything's solid through Sourcify verification and cosign signatures. And don’t worry, it’s all supported by our trusty provenance SBOMs. (github.com).

Three real‑world patterns you can copy

A loyalty appchain that comes with zero strings attached. Let's get started with an OP Stack chain--big shoutout to MIT for that! This will really boost our speed. We'll also introduce upgradeable contracts (UUPS) that come with a handy 48-hour timelock. We're set up to use blob DA (4844) by default, so just make sure the Celestia Blobstream integration is all set and ready to roll! If the fees start climbing, you can easily switch the DA just by tweaking the configuration--no need to redeploy the whole app! Check it out here: github.com.
An NFT platform that can handle vendor turnover like a champ. You can mint ERC-1155 tokens by using the {id} metadata format. Just make sure to store your JSON and media files on IPFS with a CID. So, if your current minting vendor or storage service suddenly shuts down, don’t worry too much. Any other vendor--or even your own team--can still get to those assets using the CID, and you won't have to mess around with rewriting any metadata. It’s pretty handy, right? (eips.ethereum.org).

3) Cross-ecosystem Token with Standard Bridges

Hey! If you're diving into Cosmos-aligned chains, definitely consider using IBC/ICS-20 (or maybe an EVM precompile for ICS-20) instead of leaning on a proprietary bridge. Trust me, it’ll make your life a lot easier! When it comes to Polkadot, you can just go ahead and use the XCM SDKs. They're super handy! Also, if your bridge provider decides to update their terms, you can effortlessly switch up your channels with some standard modules. It’s super straightforward! Hey, take a look at this link: docs.cosmos.network. You'll find some really useful info there!

Migration drill: rehearse the hard parts before you need them

Week 1: “Testing Things Out in the Sandbox”. First things first, you'll want to export those RPC read paths for the multi-provider fallback. And don’t forget to keep tabs on those error budgets--it's super important! How about we redirect half of our reads to the backup? (viem.sh).
Week 2: “Seamless Key Rotation”. It's time to switch up the multisig signers for the upgrade! Take some time to work on the timelock proposal queue and how to execute it. Once you've done that, don’t forget to jot down the recovery process. It’ll really help when you need to refer back to it later! (docs.openzeppelin.com).
Week 3: “Switching it Up”.
Go ahead and tweak your rollup to send it to a different DA for the next 24 hours. So, while you're at it, make sure to double-check those proofs and costs. And feel free to make any adjustments if necessary! (docs.celestia.org).
Week 4: "Time to rebuild from attestations!"
Another team is going to take a look at the cosign/SLSA attestations and the Sourcify metadata to make sure everything checks out. They’re going to move the infrastructure from Infrastructure as Code (IaC) into a new account and use a feature flag to guide the frontends. (slsa.dev).

The bottom line

Outsourcing can definitely help you get things moving faster, but it’s super important to keep a handle on some key areas. You really want to make sure you have control over upgrade rights, any chain or DA options, the essential materials, your data, and where everything comes from. It’s all about staying in the driver’s seat while you let others handle some of the work. Always keep in mind that every technical decision you make should come with a solid plan for how to back out if things don’t go as expected. A clear exit strategy is key! Consider all the proxy patterns you could set up, along with DA modules that are super easy to swap out if needed. Also, think about those RPC setups that you can multi-home, and don’t forget about the contracts that you or any auditor could review without having to wait for a vendor’s approval. It's all about keeping things flexible and straightforward!

Hey there! If you need a hand with running a 2-week “no-lock-in” audit and rehearsal, the awesome folks at 7Block Labs have got your back! They'll walk your team through the steps we've just chatted about, tailoring everything to match your unique stack and roadmap. It's all about making it work for you!

References and Further Reading:

Check out The Power of Habit by Charles Duhigg. It's a fascinating read that explores the science behind habits--why we have them and how we can actually change them. If you're looking to shake things up in your daily routine, this book is definitely worth a look!
Check out Atomic Habits by James Clear. It’s a super helpful read that dives into how to build good habits, ditch the bad ones, and really get a grip on those small actions that can lead to some incredible outcomes. Trust me, it's a game-changer!
Check out Mindset: The New Psychology of Success by Carol S. Dweck! It's a great read that dives into how our mindset can shape our success and overall happiness. Dweck dives into the concept of fixed versus growth mindsets and how these two ways of thinking can really shape our lives.
Tiny Habits by BJ Fogg - This book dives into the idea that small changes can really add up and lead to some impressive shifts in our behavior. If you're curious about how little tweaks can make a big difference in your life, this one's definitely worth a read! Check out Switch: How to Change Things When Change Is Hard by Chip Heath and Dan Heath. It's a fantastic read that dives into a solid framework for making those big changes in your life stick. If you’ve been struggling to shift habits or tackle challenges, this book might just be what you need!
Check out You Are Not a Gadget by Jaron Lanier. It’s a fascinating dive into how technology influences our humanity. You'll definitely find it thought-provoking!

Articles:

Why We Procrastinate - This article takes a closer look at the psychological factors that make us put things off. It's a fascinating read that really gets into why we sometimes find it so hard to just get things done!
The Benefits of Habit Tracking - Check out this article that dives into how keeping tabs on your habits can really help you achieve your goals and improve your life. It's amazing what a little awareness can do!
Five Ways to Change Your Habits - Here are some handy tips that could help you kickstart those positive changes in your life!

Videos:

The Science of Habits - Check out this quick video that breaks down how we actually form habits. It's super insightful and really easy to follow!
How to Build a Habit - This video is a straightforward guide that walks you through the steps to form habits that actually stick. Check it out if you’re looking to make some lasting changes!

Podcasts:

The Tiny Habits Podcast - This podcast is all about chatting about how we build habits and grow as individuals. It's a great listen if you're interested in making positive changes in your life! Check out The Mindset Mentor - it’s an awesome podcast where they explore different mindset shifts that can really help you crush your goals.
Proxies and upgrades: Take a look at OpenZeppelin Contracts 4! x/5. X and their awesome upgrade plugins. (docs.openzeppelin.com).
Diamonds (ERC‑2535): Check it out right here! (eips.ethereum.org).
EIP‑4844 (Dencun): Let’s dive into a quick overview and chat about what kind of impact it’s going to have. (datawallet.com).
Let’s talk about OP Stack licensing, fault proofs, and some interesting insights around alt-DAs. (github.com).
Arbitrum Orbit: Explore what makes it special and take a look at the BoLD timeline! (theblock.co).
Here’s the scoop on the Polygon CDK license and everything you need to know about zkEVM prover OSS licensing. (github.com).
Details on ZK Stack repositories and info about API licensing. (github.com).
Sourcify verification details. (github.com).
CAIP-2/10: Check it out here! (chainagnostic.org).
IBC/ICS‑20 and XCM SDKs: Let’s dive into the specifics! (docs.cosmos.network). Hey there! Let’s chat about some fallback providers for viem and ethers that you really should check out. (viem.sh). Hey there! If you're into node monitoring for Geth or Nethermind, you should definitely check this out! It’s a cool dashboard on Grafana. Here’s the link: Grafana Dashboard. Happy monitoring!
Check out the insights on Sigstore/cosign and SLSA provenance! (github.com). Alright, so let’s talk about the Infura/Geth situation and why the whole multi-home thing really matters.

Basically, the issue revolves around the importance of having multiple connections or pathways (that’s what we mean by “multi-home”) to access the Ethereum network. Think of it like having several routes to your favorite coffee shop--if one road is blocked, you can easily take another to still get your caffeine fix.

In the context of Infura and Geth, when there's a hiccup in the network, having that multi-home setup means users can stay connected without a hitch. It’s all about reliability and making sure people can keep accessing the services they need without dealing with downtime or disruptions.

So yeah, when we’re talking about multi-home setups, we’re really just emphasizing the need for resilience and smooth sailing, especially in a space as dynamic as blockchain. It's a big deal, and for good reason! (coindesk.com).