A small team managing a shared cryptocurrency treasury faces a practical governance problem: no single person should control the funds, yet setup must remain straightforward enough that non-technical members can participate. A multisignature wallet requires multiple cryptographic approvals before any transaction executes, distributing control and reducing the risk of theft or unilateral misuse. Safe Wallet, formerly Gnosis Safe, has become the industry standard for this use case on Ethereum and compatible chains, but lighter-weight alternatives such as Multisig.org exist and appeal to teams skeptical of complexity or seeking different feature trade-offs. The choice between them is not merely about functionality; it depends on how a team defines governance, how much on-chain cost it can absorb, and whether decentralization or operational simplicity takes priority.

Both platforms enable collaborative asset management through the same core mechanism: a smart contract wallet that enforces transaction approval thresholds before funds move. The differences emerge in architecture, user interface, supported networks, and the philosophy behind what a multisignature wallet should do. Safe has grown to support DAOs, protocols, and institutions managing billions in assets, while Multisig.org and similar projects prioritize minimal overhead and grassroots governance for smaller treasuries. Understanding these distinctions helps teams avoid the false choice between “enterprise” and “simple,” and instead match the tool to the actual governance model and risk tolerance in play.

How Safe Wallet implements multisignature architecture

Safe is deployed as a smart contract on the blockchain itself, meaning the multisignature logic and approval state live on-chain rather than on a company’s servers. When a signer initiates a transaction, the proposal is created as a contract interaction that other signers can review and approve through their connected Web3 wallets. Once the required number of signatures is reached, any account can execute the transaction. This on-chain transparency creates an immutable record: every proposal, approval, and execution is visible on the blockchain, useful for audit trails and governance documentation.

The multisignature wallet architecture also means that Safe itself does not hold private keys or custody assets on behalf of the team. Instead, the smart contract holds the funds, and signers control approval through their own wallets—typically a hardware wallet, self-custodial wallet like MetaMask, or another Web3 provider. A signer can be a person, an organization, or even another smart contract, allowing for nested governance structures. Setup requires deploying the Safe contract to the chosen network, specifying the signers and the approval threshold (for example, 3-of-5, meaning three of five signers must approve any transaction).

Safe has expanded to support multiple EVM-compatible networks including Ethereum, Polygon, Arbitrum, Optimism, Gnosis Chain, and others, making it flexible for teams that transact across multiple blockchains. The user interface, called the Safe web app, is designed to manage permissions, add or remove signers, review pending transactions, and execute approved proposals. For institutional users, Safe also offers features such as transaction guards (custom logic that enforces rules before execution), spending limits, and delegated transaction execution to reduce operational friction for routine payments.

The trade-off is that deploying a Safe contract incurs gas costs, often ranging from $50 to $500 depending on network congestion, and approving each transaction requires on-chain interactions that cost gas. For a team that transacts infrequently or on cheaper chains like Polygon or Gnosis, these costs are negligible. For teams handling small-value transactions on Ethereum mainnet during high-fee periods, the gas costs can overwhelm the benefit.

Multisig.org and the lightweight alternative approach

Multisig.org operates on a different principle: it functions as a user-friendly interface and coordination layer rather than requiring a new smart contract deployment. Instead of deploying a custom multisignature contract, Multisig.org uses a simpler model in which signers collectively hold the keys to a single account or use an existing smart contract pattern. The platform emphasizes minimalism and accessibility, reducing setup friction and gas costs for teams that do not need Safe’s advanced features.

The user experience is deliberately simplified. Multisig.org aims to help teams agree on transactions, collect signatures, and broadcast them without requiring deep technical knowledge of Ethereum or smart contracts. For a small team, micro-DAO, or informal group managing modest treasuries, this lightweight approach can be more practical. The interface focuses on transaction creation, signature collection, and approval rather than role-based access control, transaction guards, or integration with other smart contracts.

However, Multisig.org’s lighter architecture comes with limitations. It typically supports fewer networks than Safe, has less mature institutional tooling, and relies on different security models depending on the specific implementation. Some lightweight multisig platforms are open-source, while others use centralized components for key management or signature coordination, introducing new trust assumptions. Teams evaluating Multisig.org should clarify whether signatures are collected on-chain or off-chain, whether the platform stores any private key material, and how recovery works if a signer loses access to their wallet.

The community and adoption also differ. Safe has extensive documentation, integrations with popular tools, and a large installed base, which means more examples of how to configure a Safe for specific use cases. Multisig.org and similar tools often rely on smaller communities and less comprehensive resources, which can make troubleshooting or exploring advanced features more difficult for new teams.

Transaction approval workflows and governance flexibility

Both Safe and Multisig.org support configurable approval thresholds, but the way signatures are collected and enforced differs. In Safe, once a proposal is created, signers can log in to the Safe web app, view the transaction details, and approve it. The proposal is stored on-chain, and the state is immutable. If you create a proposal to send 10 ETH, that proposal persists; signers review it, approve it, and then any account can execute it once the threshold is met. This creates a clear audit trail but also means that if governance has second thoughts, the proposal must be explicitly rejected or expired rather than simply forgotten.

Multisig.org’s approach often involves off-chain signature coordination, where signers are notified (via email, messaging, or other channels) of a proposed transaction. They sign using their Web3 wallet, and once enough signatures are collected, the transaction is broadcast to the blockchain. This model can reduce on-chain clutter and gas costs but introduces a coordination layer that is not itself on-chain. If a signer’s approval email is not received or their signature is lost, recovering the transaction can be more complicated.

For governance purposes, the difference matters. Safe’s on-chain proposals make it easy for a team to audit all past decisions, see which signers approved or rejected which transactions, and even write smart contracts that depend on transaction history. Multisig.org’s off-chain coordination can be faster and cheaper, but it requires the team to maintain its own records if compliance or historical documentation is important. A DAO or protocol with governance requirements or regulatory scrutiny will likely benefit more from Safe’s transparency, while a small team managing operational expenses might prefer the simplicity and cost savings of Multisig.org.

Gas costs, network support, and scalability trade-offs

A team crypto wallet’s practical utility depends partly on how expensive it is to use. Safe on Ethereum mainnet typically costs $100–$500 to deploy, depending on gas prices, and each transaction approval adds $20–$100 per signer. For a team with an active treasury, these costs accumulate. On cheaper networks like Polygon, Gnosis Chain, or Arbitrum, the same operations might cost $1–$20, making Safe economically viable even for small treasuries.

Multisig.org and similar lightweight solutions can reduce these costs in two ways. First, if they use off-chain coordination, the signature collection itself does not incur gas fees until the final transaction is broadcast. Second, if they rely on simpler smart contract patterns or existing infrastructure, deployment and operation costs can be lower. However, this cost advantage disappears if the team later decides it needs Safe’s features, such as transaction guards or complex governance logic, because migrating from one multisignature wallet to another often requires manually re-deploying and transferring funds.

Network support is another scalability consideration. Safe is available on Ethereum, Polygon, Arbitrum, Optimism, Gnosis Chain, Avalanche, Base, and other EVM-compatible chains. This broad network coverage makes Safe attractive for teams that manage assets across multiple ecosystems. Multisig.org and lightweight alternatives typically support a narrower range of networks, which can be limiting for teams that need cross-chain treasury management. A DAO treasury wallet deployed on one network may need to manage secondary treasuries or emergency funds on other chains, and Safe’s multi-network presence simplifies that operational model.

The scalability question also concerns transaction volume. Safe is designed to handle high-frequency governance where many proposals are created and executed. If a team updates signers monthly and executes a handful of transactions, cost is low. If a team creates dozens of proposals weekly or integrates Safe with automated systems that trigger transactions based on external events, costs grow accordingly, and cheaper alternatives become more attractive.

Security model and key management philosophy

A multisignature wallet’s security depends on how signers manage and protect their private keys. Safe does not prescribe this; instead, it remains agnostic about the signer’s wallet. A signer can use a hardware wallet like Ledger or Trezor, a self-custodial software wallet like MetaMask, a smart contract-based wallet, or even a multi-party computation (MPC) service that distributes key material across multiple providers. This flexibility is a strength because it allows each signer to choose the security model that fits their risk tolerance. However, it also places responsibility on the team to ensure that signers actually use hardware wallets or similarly robust tools rather than hot wallets on a personal computer.

Multisig.org’s security model varies by implementation. If it uses an off-chain coordination layer or a key management service, the platform itself becomes part of the trust model. A team must verify that Multisig.org does not store private keys, does not act as a custodian, and does not have the ability to approve transactions unilaterally. This is a more intrusive set of questions than with Safe, where the smart contract logic is verifiable on-chain and the platform is largely transparent in how it works.

Recovery and key rotation are also different. In Safe, if a signer loses access to their wallet, the team can remove them from the multisignature wallet contract and add a replacement, but this requires a transaction approved by the remaining signers. If the number of active signers falls below the approval threshold, the team may become stuck. Best practices involve documenting signers, maintaining a recovery plan, and ensuring that at least one signer can act during an emergency. For teams considering Safe, understanding Safe Wallet login best practices before deployment is crucial to avoid operational deadlock.

Multisig.org’s recovery depends on its specific architecture. Off-chain coordination systems may offer account recovery or backup sign-in methods that Safe does not provide, but these conveniences can introduce new risks if they also enable unauthorized recovery. A team should clarify whether recovery is controlled by the platform, by the signers themselves, or by a third-party service before deployment.

Use cases: When to choose Safe vs. Multisig.org

Safe is the better choice for teams that prioritize auditability, regulatory compliance, institutional adoption, or complex governance. DAOs managing treasuries worth millions, protocol foundations, and regulated financial services often use Safe because the on-chain record, mature feature set, and broad institutional support reduce regulatory and operational risk. A DAO treasury wallet that Safe supports is easier to audit, easier to integrate with other smart contracts, and easier to explain to investors or regulators than a lighter alternative.

Safe also makes sense for teams that transact across multiple networks or integrate with decentralized finance (DeFi) protocols. If a treasury needs to approve interactions with Uniswap, Aave, or other DeFi smart contracts, Safe’s compatibility and transaction visibility reduce the risk of approving malicious or unexpected contract interactions. The transaction preview and guard features help prevent common mistakes.

Multisig.org and lightweight alternatives suit smaller teams, informal groups, and micro-DAOs with modest treasury sizes and simple governance requirements. If a team transacts infrequently, operates primarily on one cheaper network, and wants to minimize setup complexity and gas costs, a lightweight multisignature wallet can be ideal. These platforms excel at reducing friction for teams that already understand cryptocurrency and Web3 wallets but do not need enterprise features.

A practical heuristic: if the team’s treasury exceeds $100,000, involves more than 7 signers, or requires audit trails and historical documentation, Safe is likely the better choice. If the team manages less than $100,000, operates informally, and values simplicity over regulatory readiness, Multisig.org or a similar lightweight platform may be sufficient. The decision also depends on where the team plans to deploy: on Ethereum mainnet, where gas costs are high, Safe’s advantages are stronger; on a cheaper chain, both options are economically viable and the choice can rest on feature preference.

Operational considerations and onboarding friction

Setting up Safe requires understanding smart contract deployment, setting an approval threshold, specifying signers’ Ethereum addresses, and explaining to signers how to log in and approve transactions through the Safe web app. For a team entirely new to Web3, this can be a barrier. Multisig.org typically offers a faster onboarding path because it abstracts away smart contract concepts and focuses on transaction approval workflow.

However, once deployed, Safe’s operational model becomes straightforward. Signers log in with their Web3 wallet, review pending transactions, and approve or reject them. The Safe web app provides a familiar interface similar to other cryptocurrency platforms. Recovery and signer management are handled through transactions that must themselves be approved by the multisig threshold, creating a self-enforcing governance model.

Multisig.org’s operational simplicity can cut both ways. A lighter interface might reduce confusion initially, but it can also hide important details about how signatures are collected, how transactions are broadcasted, and how disputes are resolved if a signer disputes their approval. Teams should ask for documentation, examples, and ideally a test deployment before moving significant funds into any multisignature wallet.

The availability of technical support and community resources also matters. Safe’s documentation is extensive, and the team behind Safe is responsive to bugs and feature requests. Multisig.org and lightweight alternatives often have smaller support communities and less frequent updates, which can make troubleshooting more difficult if a team encounters an unexpected issue or needs to integrate with a new blockchain or token standard.

Making the transition and avoiding lock-in

One often-overlooked risk is switching costs. If a team deploys assets into a multisignature wallet and later wants to migrate to a different platform, moving funds requires approval from the current multisig threshold, which means coordinating signers to approve a withdrawal. If signers have changed, are unresponsive, or have left the team, this can become a serious operational problem. The funds are never technically locked—the multisig rules can be changed to remove unresponsive signers and add new ones—but the governance overhead increases.

Safe’s broad adoption and interoperability mean that migration is relatively straightforward. If a team starts with Multisig.org and later wants to move to Safe, they can create a new Safe, obtain a multisig signature on a withdrawal from the old platform, and transfer funds to the new Safe. The process is tedious but not technically blocked.

To minimize regret, teams should treat the choice of multisignature wallet as a deliberate governance decision rather than a casual selection. Before deploying, document why the team chose that platform, what the approval threshold and signer list are, and what the plan is for adding or removing signers. This documentation becomes valuable when team membership changes or if the team later needs to explain the setup to new members or auditors.

Version upgrades and protocol changes also matter. Safe has a clear upgrade path, and the team continues to add features and improve the interface. Multisig.org and lighter alternatives may move more slowly or discontinue support if the project is community-run. A team should verify whether the platform is actively maintained, whether bug fixes are released promptly, and whether there is a plan to support new blockchain networks or token standards as they emerge.

A Solana staker faces a recurring operational challenge: understanding what happens to their delegated tokens between epochs, verifying that validator operators are actually producing blocks, and detecting when rewards are delayed or miscalculated. The Solana network moves fast—epochs last approximately two days, block times average 400 milliseconds, and validator performance can shift rapidly. Manual calculation of rewards from chain data is error-prone and time-consuming. The practical solution is to use the official blockchain explorer purpose-built for this task, where epoch transitions, validator metrics, and reward distributions can be tracked in real time without requiring a local node or custom scripts.

Staking represents a meaningful commitment of capital and trust. Delegators choose validators based on reputation, commission rates, and perceived stability, but verification requires more than reputation signals. A validator might claim competitive performance while actually skipping slots, missing epoch transitions, or running outdated software. Solscan, the official blockchain explorer for the Solana network, surfaces the data that demonstrates whether a validator is genuinely earning rewards or accumulating technical debt. The platform combines raw blockchain information with human-readable summaries, making it possible for both casual stakers and professional node operators to monitor their participation without diving into Rust source code or binary data.

Understanding Solana’s epoch model and why it matters

A Solana epoch is a fixed period of time during which validator assignments remain constant. Each epoch lasts approximately 432,000 slots, which translates to roughly two days of continuous block production at the network’s target slot time. During an epoch, the network selects a specific set of validators to produce blocks in rotation, and their voting weight is determined by the amount of SOL delegated to them. At the conclusion of an epoch, all staking rewards are calculated and distributed, and the protocol generates a new validator schedule for the next epoch. This design creates distinct observation windows where staker performance and validator contributions can be measured and compared.

The epoch boundary is the moment when your staking rewards materialize. Solana’s staking mechanism distributes inflation-based rewards according to a formula that accounts for the total network stake, the validator’s uptime and slot performance, and the duration of the staking period. A validator that missed slots during the epoch will see reduced rewards, and stakers delegated to that validator will receive proportionally fewer tokens. This is not a penalty in the traditional sense; rather, it is a direct consequence of the validator not fulfilling its assigned block production responsibility. Understanding when epochs transition and what happened during the completed epoch is therefore essential to detecting whether your validator is performing well.

Solscan provides epoch information in multiple views. The main epoch page displays the current epoch number, its start and end times, the percentage of the epoch completed, and a live countdown. Historical epochs can be reviewed to understand trends across multiple staking periods. For a staker concerned about recent underperformance, comparing the last five epochs can reveal whether poor results are a temporary anomaly or a persistent issue. The platform also displays the validator set for each epoch, so a staker can confirm whether a validator was selected at all or was deactivated by the network.

Finding and analyzing validator block information

Validator monitoring begins with identifying the correct validator public key and then observing its behavior during one or more epochs. Solana’s network currently includes hundreds of active validators competing for delegations and rewards. Solscan maintains a searchable directory where validators can be located by name, public key, or commission rate. Once a validator is selected, its detailed performance page shows critical metrics: the number of slots assigned during the current epoch, the number of slots actually produced, the block information confirming each production, the validator’s commission percentage, and the total active stake delegated to it.

Block information on Solscan includes the block number, timestamp, block producer identity, number of transactions processed, and total fees collected. For a validator, each produced block represents successful fulfillment of a slot assignment. A validator assigned to produce block 150,000,000 must broadcast a valid block containing transactions and the required cryptographic commitment to the previous block. If the validator fails to produce a block in its assigned slot—whether due to downtime, network issues, or software bugs—that slot is skipped and assigned to another validator. Tracking block information across an epoch reveals the validator’s actual slot performance rate, which directly determines reward eligibility.

The relationship between assigned slots and produced blocks is expressed as a percentage. A validator with 95 percent slot performance produced valid blocks in 95 of every 100 assigned slots. This metric is more reliable than claims made in the validator’s marketing materials or community reputation. A validator that was inactive for several weeks may appear to recover in the current epoch, but its historical block information provides evidence of whether the recovery is genuine or temporary. Solscan displays this history in graphical and tabular formats, making it possible to spot patterns: perhaps the validator consistently drops blocks at certain times of day, which might indicate a timezone-related maintenance window or resource constraint.

Tracking staking rewards in real time

Staking rewards on Solana are not distributed continuously. Instead, they are calculated at the conclusion of each epoch and transferred to staking accounts automatically. The inflation schedule determines the total number of SOL created as staking rewards each year, and the on-chain program divides this pool among validators according to their performance and stake weight. A staker delegated to a validator with 5 million SOL of delegations will receive more total rewards than a staker with the same percentage of that validator’s stake if a different validator receives more delegations, because rewards are inversely related to total network stake (all else equal, validators on a less-saturated network tend to receive higher rewards per SOL).

Solscan’s reward tracking tools display historical rewards earned by a validator across recent epochs. By filtering rewards by epoch, a staker can see exactly how much SOL was distributed to that validator, how many active stakers shared it, and what percentage increase a single SOL stake received. If a staker had 100 SOL delegated to a validator that earned 10 new SOL total and distributed it among 1,000 SOL of total delegations, the staker would receive 1 SOL (10 percent of 10). Comparing this calculation across multiple epochs reveals whether a validator’s reward distribution is consistent or declining. A sudden drop in rewards may indicate decreased performance, loss of delegations (reducing the validator’s share of inflation), or a change in the validator’s commission rate.

The reward epoch view also clarifies commission behavior. Validators charge commission on the rewards they distribute, meaning they deduct a percentage before depositing the remainder into staker accounts. A validator with a 5 percent commission charges 5 percent on all earned rewards, not on the delegated stake itself. Over many epochs, this compounds. A staker receiving 10 SOL per epoch from a 0 percent commission validator will accumulate 520 SOL per year; the same staker delegated to a 10 percent commission validator earning the same gross amount will accumulate 468 SOL, a material difference. Solscan makes this comparison transparent by showing both the validator’s earnings and the staker’s net distribution.

Using real-time updates for timely decision-making

Solscan provides real-time updates of block information, transaction processing, and validator status. This is not merely a convenience feature; it addresses a genuine operational need in the Solana ecosystem. Because epochs last only approximately 48 hours and validator performance can degrade rapidly, waiting days to discover that a validator has become unreliable can cost significant rewards. Real-time updates enable a staker to detect problems within hours rather than weeks. If a validator begins missing slots consistently, this pattern becomes visible within the first few hours of the epoch, making it possible to redelegate before rewards are finalized.

The platform’s status pages and alert integrations (where available through community tools) can notify stakers of validator downtime or slot performance below a threshold. A validator that produced 98 percent of slots during the previous epoch but is now at 60 percent suggests an acute problem: perhaps a software upgrade failed, a network connection dropped, or the validator is under unusual load. Real-time visibility into block information allows a staker to correlate this performance change with external factors. If a validator that operates in a specific geographic region begins dropping slots during a particular time window, this might indicate a data center issue or BGP routing problem affecting that location. Waiting until the epoch ends to observe the performance data makes it difficult to understand the root cause.

The decision to redelegate is never trivial. Unstaking and restaking to a new validator requires waiting one epoch for the tokens to cool down before they earn rewards again, resulting in a missed rewards period. A rational staker will therefore only redelegate if the evidence of persistent poor performance is clear. Solscan’s real-time data and historical comparisons provide that evidence. A validator that produced 95 percent slot performance in the last five epochs but dropped to 40 percent in the current epoch, with no recovery signal, represents a sufficiently changed risk profile to warrant redelegation despite the one-epoch opportunity cost.

Validator monitoring tools and custom searches

Beyond the pre-built epoch and validator pages, Solscan offers advanced search and filter capabilities designed for detailed analysis. Stakers can search by validator public key, token address, or transaction ID, and filter results by date range, transaction type, and value. For a staker wanting to verify that a specific reward transaction was processed correctly, searching by transaction ID returns the full details: sender, recipient, amount, timestamp, and confirmation status. This eliminates reliance on a validator’s own reporting and confirms that the on-chain record matches expectations.

The token and coin overview pages provide context on the broader staking economics. A staker considering whether to move delegations from one validator to another can examine SOL’s current supply, circulation rate, inflation schedule, and how recent rewards compare to historical levels. If the network-wide reward rate has declined, this might reflect increasing total stake rather than validator-specific underperformance. Conversely, if rewards are rising while a specific validator’s rewards stagnate, that validator may be losing delegations or experiencing technical degradation. Solscan’s real-time updates ensure that this analysis is based on current data rather than cached or delayed information.

For developers and sophisticated stakers, Solscan provides API access to retrieve raw blockchain data programmatically. Rather than manually checking the Solscan web interface multiple times per day, an API client can query validator performance, reward calculations, and epoch transitions at intervals and generate custom reports or alerts. This enables automated monitoring of multiple validators, comparative analysis across time periods, and integration with portfolio tracking systems. The API requires no private key access, ensuring that monitoring does not compromise staking security.

Common staking mistakes revealed by Solscan data

Solscan’s transparency frequently exposes misconceptions that new stakers hold. One widespread error is assuming that a validator with “low commission” is automatically a better choice. Commission matters over long time periods, but validator performance matters more immediately. A 0 percent commission validator that misses 20 percent of slots will distribute fewer rewards than a 5 percent commission validator that misses 5 percent. Solscan’s historical data makes this comparison explicit. A staker reviewing the last 10 epochs of reward distributions can calculate the total rewards each validator paid and make an informed decision regardless of marketing claims.

Another common mistake is redelegating after a single poor epoch without waiting to see whether the problem persists. Validators experience occasional network issues, software updates, or temporary overload. A single missed epoch does not necessarily indicate long-term unreliability. Solscan’s epoch history allows a staker to place one poor epoch in context: if it is an outlier against nine good ones, the validator may be worth retaining. If the trend is clearly declining, the data supports redelegation. By making block information and reward distribution visible, Solscan encourages evidence-based decisions rather than panic-driven movements.

A third error is failing to account for the unstaking cooldown period. Some stakers discover that their chosen validator has declined in performance and immediately redelegate, not realizing that the prior delegation must cool down for one full epoch before the new delegation begins earning rewards. This results in lost rewards during the transition. While Solscan cannot prevent this mistake, it can clarify what the stakes are: checking the current epoch progress before initiating a redelegate helps a staker choose the optimal timing to minimize the cooldown cost.

Integrating Solscan into a staking monitoring routine

An effective staking strategy incorporates regular monitoring into a structured routine. A casual staker might check Solscan weekly: reviewing the previous epoch’s rewards, confirming that the chosen validator maintained acceptable performance, and noting any changes in commission or validator status. This weekly rhythm is sufficient to catch serious problems—a validator that failed catastrophically will be obvious within days—while avoiding the cognitive load of constant checking. Solscan’s epoch pages can be bookmarked, making weekly review a matter of seconds.

For stakers managing larger delegations or running their own validators, more frequent monitoring is justified. Checking Solscan daily, or even setting up API-based alerts, helps detect emerging problems before they compound. A validator might experience a transient issue that resolves quickly, but if the same issue recurs multiple times per week, it signals a systemic problem worth addressing. Solscan’s real-time updates make this pattern detection possible without requiring manual inspection of each epoch’s block information.

Integration with other tools enhances the value of Solscan monitoring. A staker might use Solscan to track validator performance, a wallet application to manage delegations, and a spreadsheet or portfolio tracker to calculate realized returns. By combining data from these sources, a staker builds a comprehensive view of their staking activity. Solscan serves as the authoritative source for on-chain data, and other tools add layers of analysis or convenience. This modular approach avoids depending on any single platform while leveraging each tool’s strengths.