Strategic Guide - Risks
- What this guide is: an honest catalogue of the downsides, limits, and open questions of adopting KernDX, written for the people whose job is to find them.
- Why it exists: no framework is the right choice everywhere, and a governance review deserves a straight answer rather than a sales pitch. This guide names where KernDX is the wrong fit, where a specialist library does a particular job better, what could go wrong technically and organisationally, and how each risk is mitigated.
- Who should read it: architects, governance reviewers, and the executives or delivery managers who sign off on a framework.
- When to use it: when you are weighing KernDX against the alternatives, or preparing for the questions an architecture review board will ask.
Part of the KernDX Strategic Guide. See also: Architecture & Philosophy | Adoption | Operations | Glossary | Personas
Primary reader: an architect, governance reviewer, or executive evaluating the downsides of adoption, including the hard questions an architecture review board will ask. For decision support and the roll-out plan, see Adoption. For runtime operating-cost and exit mechanics, see Operations.
Table of Contents
- When NOT to Use KernDX
- When a Modular Stack Fits as Well
- Risks, Mitigations & Trade-offs
- Technical Risks
- Organisational Risks
- Ecosystem Risks
- Enterprise Risk Dimensions
- Potential Drawbacks
- Modular Stack Risks
- What if the maintainer leaves?
- Community Support: Signal vs Substance
- Governance Model
- Versioning & API Stability
- Adoption Gate Criteria
- Hard Questions Architecture Review Boards Will Ask
- Strategic Recommendations
When NOT to Use KernDX
KernDX is a broad foundation that you adopt one feature at a time, but it is not the right choice everywhere. The table below names the situations where a different choice is genuinely better, and what to pick instead. Where no library is better but moving still has a cost, the row weighs what moving costs against what staying costs. Read it before you read anything KernDX does well: if your situation is in this list, the rest of the strategic guides matter less than the row that fits you.
| Scenario | Constraint | Why KernDX Fits Poorly, or What Each Choice Costs | Recommended Alternative |
|---|---|---|---|
| Logging with a feature KernDX does not have | You rely on one of nebula-logger's four extras | nebula-logger ships four things KernDX does not: the choice of how each log is saved, seven log levels, a retention date per log entry or scenario, and archiving to a Big Object. KernDX keeps logs for one org-wide window, with no archive. If you need none of the four, you can adopt KernDX's logging on its own, like any KernDX feature, and its unused code is inert in a managed package (see the notes below the table) | nebula-logger, for those four features (it can run alongside KernDX) |
| Domain-Driven Design is required | Complex domain model with bounded contexts | KernDX ships the domain layer through trigger actions, but no service layer or application factory | fflib or at4dx |
Your org already runs a trigger or query library, such as taf or apex-fluently-soql | Moving costs a migration; staying keeps what those libraries leave out | Weigh both costs. Moving: for taf, porting each action class and its registration to a KernDX record; for apex-fluently-soql, rewriting your queries. Staying: a taf trigger bypass leaves no record, and apex-fluently-soql's opt-out from permission checks is a per-call method that leaves no record, with no org-wide off-switch. Each library has pieces KernDX lacks, named in the notes below the table; none is a reason to choose them, because KernDX covers everything else they do | No library pick: weigh the two costs. If you stay, you can still add KernDX features one at a time beside them (see the Coexistence Playbook) |
| Consulting project handed over to a client team that knows another stack | The client team maintains the code after handover | Weigh both costs. Staying in the stack the client team knows: in most other Apex libraries a bypass leaves no record (see "Why this matters" under Technical Risks), and the team keeps connecting and upgrading separate libraries itself. Moving: the migration, and the time to learn each KernDX feature you hand over (see the notes below the table). Unless the team relies on a capability KernDX lacks (this table and Potential Drawbacks list them), no capability decides it | No library pick: agree the choice with the client team, with both costs stated |
| Multiple independent delivery partners with no shared governance | No central architectural authority to enforce conventions | KernDX's value depends on consistent usage; ungoverned adoption results in partial framework use | Set up shared governance first: either approach fragments without it (see the analysis in Adoption of several delivery partners, or systems integrators, working in one org). |
| Public ecosystem credibility is a hard requirement during the immediate procurement window | Architecture board requires multi-contributor community validation at install time | KernDX meets the licence and public-repository part: it is open source under the Apache License 2.0 (approved by the Open Source Initiative, OSI) in a public repository. What differs: it has a single maintainer today (see the date in the Metrics guide), its public commit history is short, and it does not accept pull requests from outside contributors yet (issues and feature requests are welcome). Most comparable Apex frameworks are also single-maintainer (only the fflib project has several maintainers), so the number of maintainers is what decides this case. See What if the maintainer leaves? | Only the fflib project, if multi-contributor maintainership is required |
| Your compliance rule requires the code to come from several separate suppliers | Compliance requires a demonstrable multi-vendor supply chain | KernDX comes from one maintainer. Its source and commit history are public, but the public commit history is short | Libraries from separate authors meet the letter of this rule. Most of them still have one main author each; only the fflib project has several maintainers |
Notes on the rows above:
- Logging. KernDX's Log Console covers browsing, search, grouped recurring problems and a per-operation drilldown. On masking by default, both mask card numbers in logs;
nebula-loggeralso masks US social security numbers, and KernDX also masks secrets across its diagnostic objects, log events included, with more tested rules you can switch on for any object. - A trigger or query library you already run.
apex-fluently-soqland KernDX both run reads with the user's permissions by default (USER_MODE: the current user's read and write permissions and record sharing enforced).tafand KernDX both react to record-change events and run follow-up work after the transaction commits.tafhas one piece KernDX lacks, typed collection input for Flow trigger actions (a platform limit; see Potential Drawbacks).apex-fluently-soqlhas a few, such as condition logic written as text ('1 OR (2 AND 3)'). None is a reason to choose them: KernDX covers everything else they do. - Handover learning time. Each KernDX feature has a timed, guided Fast Start and ApexDoc in your IDE (see Onboarding Time Comparison; its columns are not measured alike: KernDX's is timed on a guided path, the others are estimates from reference pages).
When a Modular Stack Fits as Well
Sometimes a hand-picked set of separate libraries (a modular stack) fits as well as KernDX. The table below names those cases and gives both sides of each, so you can see what you take on either way.
One note first. When this guide says "modular" it means separate libraries you install and own one at a time, not the size of the contributor community. Most of the popular modular libraries are themselves single-maintainer projects (most comparable Apex frameworks are single-maintainer; only the fflib project has several maintainers). So if your requirement includes multiple active maintainers, read What if the maintainer leaves? before assuming "modular" means "community-maintained".
| Scenario | Why a modular stack fits | The other side |
|---|---|---|
| Highly specialised internal Salesforce teams with deep platform expertise | Your team can pick each library and keep the code consistent through its own expertise rather than framework enforcement | That consistency lasts as long as the people who hold it; KernDX builds the checks into the framework, so they hold when people change |
| Organisations with long-term in-house ownership and stable engineering teams | Institutional knowledge persists, and conventions the team culture enforces do the job of framework-imposed ones | The same as above: conventions held by people last as long as those people. A stack also means several libraries to connect, upgrade and security-review |
| Teams that want no single central dependency | Each library is a separate dependency you can drop on its own | KernDX is also free and open source, and it is also adopted and left one feature at a time; a stack means several dependencies to upgrade and security-review instead of one |
| Platform R&D orgs experimenting with architectural patterns | Trying a new library in one area at a time is the point of the work | KernDX is adopted one feature at a time too, and your own code may still use another library in any area |
| Your procurement rule requires several active maintainers, or an outside contribution model | Only the fflib project has several maintainers (see What if the maintainer leaves?); most other community libraries are single-maintainer too | KernDX's source and commit history are public, but it has one maintainer, a short public commit history, and does not accept pull requests from outside contributors yet (issues and feature requests are welcome) |
In these cases a modular stack fits. Weigh what it asks of you too: you connect the libraries yourself, upgrade and security-review each one, and the Apex of a library you deploy as source counts toward your org's 6 MB Apex limit. For a capability-by-capability comparison of KernDX against each of these libraries, including where another library has something KernDX does not, see Choosing a Framework.
Risks, Mitigations & Trade-offs
The tables below lay out the known risks of both approaches, side by side: adopting one integrated framework like KernDX, and assembling your own modular stack from separate libraries. For each risk you get how likely it is, how much it would hurt, how feasible the mitigation is, and the net exposure that remains after mitigation. The point is to let you compare like with like rather than to argue one approach is risk-free.
Technical Risks
| Risk | Likelihood | Impact | Mitigation Feasibility | Net Exposure | Justification |
|---|---|---|---|---|---|
| Package overhead in CPU-intensive operations | Low | Low | High | Low | Pre-compiled managed package; benchmark hot paths |
| Dependency on Salesforce platform roadmap | Medium | Medium | High | Low | Standard Apex only; no unsupported API usage |
| Managed package namespace constraints | Low | Low | High | Low | Three exit paths including namespace removal |
| Metadata configuration sprawl | Medium | Medium | High | Low-Medium | Document the metadata inventory. For deeply adopted orgs, migration takes ~1-2 days when done by an AI coding tool working from the instruction files for AI coding tools (or 1-2 weeks done by people alone). Mitigation Feasibility is rated High because a team with AI coding tools can now run the exit routinely, so the remaining risk fits inside a single sprint rather than a multi-week project. |
| Over-abstraction risk | Low | Medium | High | Low | Incremental adoption; unused modules are inert |
| Developer cognitive load | Medium | Low | High | Low | Per-module learning; AGENTS.md + docs/Code Conventions - Guide.md + Fast Starts reduce ramp |
| Framework updates break existing code | Low | High | High | Low | Version locking in the second-generation managed package (2GP); sandbox testing before production; semantic versioning |
| Static methods harder to mock in tests | Low | Low | High | Low | Built-in mocking: QRY_Builder.setMock(), TST_Mock.register(), API_MockFactory |
Data Access Governance on auxiliary read paths (framework-internal SYSTEM_MODE selectors) | Low | Low-Medium | High | Low | By default KernDX queries and writes (QRY_Builder / DML_Builder) run with the current user's permissions and record sharing enforced (USER_MODE), on both read AND write. Framework-internal selectors deliberately run in SYSTEM_MODE instead; this is a design choice, not a bypass. Why, and how it is checked, is in the notes below the table. |
| Critical bug in managed package class | Low | High | Medium | Medium | Handler bugs: bypass via metadata. Infrastructure bugs (QRY_Builder, DML_Builder): you cannot hotfix these yourself; fixing one needs a new package version from the vendor or taking source ownership and repackaging. This is the same constraint as Financial Services Cloud / CPQ. |
Notes on the Data Access Governance row (the framework's own SYSTEM_MODE reads):
- Why these selectors run in
SYSTEM_MODE. The framework has to read its own configuration, logs and permission records whatever the running user may see. So these selectors run inSYSTEM_MODE(which skips those object and field permission checks, leaving record sharing to the calling class) viaSEL_Base.systemModeRequired(). - How they are checked. Every such selector is documented and declares it in source, where git history and code review see it. The access-mode scanner, which blocks the build in continuous integration (CI), fails a build when a query or save written with the builders names no access mode. It does not look at selector reads, so code review is where these declarations are checked.
- How to revert. Metadata flags act as a master off-switch you can flip in an incident without a deployment: change one record, no code deploy, to revert if you hit unexpected access denials.
Every change to the public repository is scanned in continuous integration (CI) with Salesforce Code Analyzer's AppExchange rule set. The run fails on any finding that is not already explained, and SECURITY.md explains each known finding and why it is not a vulnerability.
Fixing a top-priority production incident (P1) without a vendor release: A common architecture-board concern with managed packages is: "What if a critical bug is found inside a framework class and the vendor is unavailable?" KernDX's metadata-driven architecture provides multiple isolation mechanisms that do not require code deployment or a new package version:
| Mechanism | Scope | Action | Code Deploy Required |
|---|---|---|---|
TRG_Base.bypassAction(className) | Single trigger handler | Programmatically skip a specific handler for the remainder of the transaction | No (Apex API call) |
TriggerSetting__mdt.BypassExecution__c | All handlers for an object | Declaratively disable all trigger processing for an SObject type | No (metadata deploy) |
FeatureFlag__mdt | Entire feature path | Disable a feature flag, which prevents associated trigger actions from executing | No (metadata deploy) |
| Web service feature flags | Specific API handler | Disable outbound/inbound web service processing via FeatureFlag__mdt | No (metadata deploy) |
| Chain Monitor stop action | Single running chain | Stop a background chain that is already running; ends at the next step boundary | No (console action) |
| Source ownership + repackaging | Any framework class | Fork the public source (Apache 2.0), fix the bug, repackage under client namespace | Yes (the exit strategy) |
The chain stop needs one piece of setup before an incident, not during one. It sits behind a permission set that ships assigned to nobody, and whoever holds that permission also needs a permission set that can read chain data, such as Kern Async Chain Monitor Read Only, so assign both to your on-call operators while things are calm.
The framework's chain recovery job works the same way: it runs only once an admin schedules it (the Health Check offers a one-click way to schedule it). Once scheduled, it checks whether a chain's work is genuinely still running:
- It recovers the runs it can prove died. It runs the stalled step again only when that is safe, and otherwise ends the run as failed so nothing is done twice.
- It marks the ones it cannot prove dead for a person to look at rather than touching them.
- A restarted run picks up under the framework's default settings rather than the settings its original builder set.
Bypasses are audit-logged by default, so you can see who turned a safety check off and why. Every bypass made through the builders, every trigger bypass and every validation-rule bypass writes a structured audit event via LOG_Builder, carrying the W3C correlation ID (one tracking ID that follows a single user action across triggers, queries, callouts and jobs).
That means each of those bypasses is traceable across triggers, async chains, and API calls, whether it was a deliberate P1 mitigation or an accidental call inside a loop. You get auditable evidence of each of those bypasses without writing any logging code yourself. The three lower-level save methods your code can call directly (DML_Transaction.setAccessLevel(AccessLevel.SYSTEM_MODE), DML_Transaction.commitWork(false), and PROC_ExecuteDML built with AccessLevel.SYSTEM_MODE) write an entry too.
How to read it back: one query lists each distinct bypass with its user and first reason (LogEntry__c rows whose Fingerprint__c starts with detail:bypass:, with the user in UserId__c and the reason in ContextData__c), the rollup:bypass: rows give the days and counts of repeats, and the Security Guide shows both queries.
Two things to know:
- What turns it off. A bypass entry is saved at every log level, ERROR included, while logging is on (
IsEnabled__conLogSetting__c) and theBypassAudit_Enabledfeature flag is on; those two are its off-switches. A class filter or a suppression on the log setting that leaves out a class also hides that class's bypass entries, and a caller that carries a namespace (yours, or the framework's own audit class when no class of yours made the call) is matched by its namespace, not its class name. Each bypass entry also publishes one platform event, at every log level. - Repeats. A repeat, meaning the same user making the same bypass (same action, same part of the framework and same target) from the same class and method, adds no new entry. The first entry keeps the first time and reason until log retention deletes it. A daily summary row (
Fingerprint__cstarting withrollup:bypass:) counts the repeats and keeps that day's first reason. A different reason given later the same day is not kept.
Why this matters: it is not the norm. Across comparable Apex frameworks, only KernDX records bypasses automatically, with the user and the reason.
- Two others write something in narrow cases. ApexKit saves a free-text entry, with no field for the user, for one kind of explicit trigger bypass.
rflibwrites a warning at its org-wide and per-user trigger switches that is not saved by default. - The others leave no trace when a check is switched off.
taf's bypass methods,fflib's static Boolean off-switch,apex-libra'sdisableTrigger/asSystemWithoutSharing, and the bypass methods of the Apex Fluently libraries all leave no trace on bypass.
Two kinds of bug, with honest trade-offs:
Kind 1, bugs in the handlers you plug in (trigger actions, API handlers, chain steps): The bypass mechanisms above let you disable the faulty handler and deploy a temporary replacement in your own code. This is a real, tested mitigation, and it needs no vendor involvement. If a faulty chain step is already mid-run, the Chain Monitor stop action ends that run at its next step boundary.
Kind 2, bugs in the framework's infrastructure classes (QRY_Builder, DML_Builder, TRG_Dispatcher, LOG_Builder): you cannot hotfix these. They are compiled inside the managed package, and no bypass mechanism helps because your code calls into them. Your options are: wait for a new package version from the vendor, work around the specific bug in your own code (for example, write raw SOQL for the affected query pattern), or trigger the source-ownership exit strategy. This is the inherent trade-off of any managed package: Salesforce's own products (Financial Services Cloud, CPQ, Health Cloud) carry the same constraint.
What reduces the risk of kind 2 bugs: Infrastructure classes are the most stable and most heavily tested components in the framework.
- Tests. They are covered by the framework's Apex test classes and their
@IsTestmethods plus the Lightning Web Components (LWC) Jest suite, gated at 100% per-file Apex coverage and 95% statement/branch LWC coverage, enforced at every release build. - Release tests. They are validated against the release tests, run in a separate org with the package installed the way you would install it (anonymous-Apex assertions across its numbered sections, plus
@IsTestmethods across the test classes in that org). - Change rate. They change less frequently than handler logic and are validated across every package build (151 published managed-package versions declared in
sfdx-project.json).
The risk is real but low-probability. Before adopting, your org should evaluate whether the vendor's support responsiveness is acceptable for your service-level agreement (SLA), and keep the exit-strategy documentation current.
What ClassTypeResolver__mdt provides: a way to extend the framework, not to replace it. You inject your own new handlers, strategies, and chain steps into the framework's resolution chain by adding configuration records (custom metadata); the framework then finds those classes in your namespace at runtime via UTIL_System.getTypeForClassName(). This is a dependency-injection mechanism for extending the framework, not a hotfix path for replacing package internals.
Organisational Risks
| Risk | Likelihood | Impact | Mitigation Feasibility | Net Exposure | Justification |
|---|---|---|---|---|---|
| Knowledge concentration (bus factor) | Medium | High | Medium | Medium | Source ownership + AI-context files (AGENTS.md + docs/Code Conventions - Guide.md at repo root plus the AI Agent Instructions framework reference), 38 developer documents, API reference pages, standard patterns, metadata-driven bypass for P1 isolation |
| No public community | Medium | Low | Medium | Low | Documentation + AI context for self-service |
| Limited market familiarity | Medium | Low | High | Low | KernDX uses standard Apex patterns (selectors, triggers, and DTOs, the small classes that hold exactly the fields you move in or out and convert themselves to and from JSON); the ramp gap is per-module API familiarity, not a language or paradigm change. Each module has a timed, guided Fast Start and ApexDoc in your IDE (see Onboarding Time Comparison; its columns are not measured alike: KernDX's is timed on a guided path, the others are estimates from reference pages) |
| Internal support dependency | Medium | Medium | Medium | Medium | Source ownership + exit strategy |
| Developers misuse static utilities | Medium | Medium | High | Low | Code review standards; limit scope to infrastructure |
| Agentforce Vibes lock-in | Medium | Medium | High | Low | Instruction files work with any AI tool (Claude Code, Cursor, Cline) |
Ecosystem Risks
| Risk | Likelihood | Impact | Mitigation Feasibility | Net Exposure | Justification |
|---|---|---|---|---|---|
| Salesforce deprecates platform features used by framework | Low | High | High | Low | Standard Apex only; no unsupported APIs |
| Competing frameworks improve significantly | High | Low | High | Low | Framework is an accelerator, not a locked dependency |
| AI tooling reduces framework value | Medium | Medium | Medium | Medium | AI tools work with conventions, not against them |
| Abandoned library risk (modular stacks) | Medium | High | Medium | Medium | Open-source libraries depend on maintainer motivation; fork potential mitigates |
Enterprise Risk Dimensions
These are the risk categories an architecture board usually scores a framework against. For each one, this section says whether KernDX makes the risk worse ("amplifies") or better ("mitigates"), and what backs that up. Where a modular stack faces the same category differently, that is noted too.
- Concentration Risk (single maintainer)
- KernDX: Amplifies, because there is a single primary developer. This matches the norm across comparable Apex frameworks: most are also single-maintainer (only the
fflibproject has several maintainers). - Mitigation: the source is open source under the Apache License 2.0, so any team can clone and self-maintain regardless of vendor status, and consulting engagements include direct source delivery and handover support. On top of that you get standard Apex patterns, AI-context files, 38 developer documents, and shipped repackaging-under-client-namespace tooling.
- Audit framing: the question your audit team needs to answer ("is the framework defensible if the maintainer is unavailable?") can be answered straight from the documentation inventory (What if the maintainer leaves? below), rather than depending on one person's availability. The checks and conventions are documented in the repository and built in, not left to every developer to remember from the maintainer's memory.
- KernDX: Amplifies, because there is a single primary developer. This matches the norm across comparable Apex frameworks: most are also single-maintainer (only the
- Upgrade Risk (API instability)
- KernDX: Mitigates on the released line, through semantic versioning and a
globalAPI stability commitment - Mitigation: 2GP version locking, sandbox testing before production
- KernDX: Mitigates on the released line, through semantic versioning and a
- Survivability Risk (abandonment)
- KernDX: Low. The source is open source under the Apache License 2.0, so any team can fork and self-maintain regardless of vendor status. KernDX is one of the few Apex frameworks that ships explicit repackaging-under-client-namespace tooling and an
Unmanaged.zipexit artefact, so the practical exit path is more thorough than "source on GitHub" alone. - Mitigation: Public source access, standard Apex patterns, shipped repackaging tooling, documented exit strategy to modular stack.
- KernDX: Low. The source is open source under the Apache License 2.0, so any team can fork and self-maintain regardless of vendor status. KernDX is one of the few Apex frameworks that ships explicit repackaging-under-client-namespace tooling and an
- Hiring & Ramp Risk (per-framework familiarity in the hiring pipeline)
- This guide does not measure how deep the hiring market is for any framework, KernDX or its alternatives, so a claim that "this framework is easier to hire for" is not something you can rely on without your own data. Each KernDX module has a timed, guided Fast Start and ApexDoc in your IDE (see Onboarding Time Comparison; its columns are not measured alike: KernDX's is timed on a guided path, the others are estimates from reference pages).
- KernDX: it uses standard Apex patterns (selectors, triggers, DTOs) that transfer from
fflibortafexperience, so the ramp gap is per-module API familiarity, not a paradigm shift. In high-turnover environments, base adoption decisions on your team's own historical onboarding data, not on generic hiring-market claims about any specific framework. - Mitigation: KernDX documentation depth (21 developer guides, 17 Fast Starts, API reference pages) plus
AGENTS.mdanddocs/Code Conventions - Guide.mdreduce per-new-hire ramp time; measure against your team's own baseline.
- Governance Drift Risk (different teams gradually picking different patterns)
- KernDX: Mitigates, because the managed package keeps the conventions in one place
- Modular stacks: Amplifies, because they require active architectural discipline across independent libraries
- Vendor Lock-in Risk (internal framework dependency)
- KernDX: Low. It is a managed package with three explicitly documented exit paths (namespace removal, unlocked conversion via
Unmanaged.zip, and repackage-under-client-namespace using the shipped tooling). KernDX is unusual among comparable Apex frameworks in shipping a complete repackaging workflow as a first-class exit path, not just publishing source on GitHub. - Mitigation: Three documented exit strategies plus public source access under the Apache License 2.0.
- KernDX: Low. It is a managed package with three explicitly documented exit paths (namespace removal, unlocked conversion via
- Architecture Board Approval Risk (governance review criteria)
- KernDX: Moderate. The licence raises no concern: KernDX is open source under the Apache License 2.0, approved by the Open Source Initiative (OSI), with the source in a public repository. What a board may still weigh is the single maintainer today (see the date in the Metrics guide).
- Mitigation: Documented governance model, open source under the Apache License 2.0, standard Apex patterns, time-boxed pilot.
Potential Drawbacks
These are the specific things KernDX does not do, or does in a way you may not expect. Several rows name a competitor that does a particular job better; those concessions are real, and the alternative is named so you can judge whether the gap matters for you.
| Drawback | Context |
|---|---|
| The whole package installs at once | You adopt it one feature at a time. Unused code is inert (no CPU, no governor limits). KernDX's code does not count toward your org's 6 MB Apex limit when you install the managed package, and it is not copied into your org as your own source. |
Framework-internal SYSTEM_MODE selectors (auxiliary read paths) | QRY_Builder and DML_Builder default to USER_MODE (the running user's permissions and sharing enforced) on read AND write. The framework has to read its own configuration whatever the running user may see, so framework-internal selectors (configuration reads, Chain Monitor aggregates, and similar) run in SYSTEM_MODE by design, via SEL_Base.systemModeRequired(), a documented method a selector overrides. It is a design choice, not a bypass. How these selectors are checked, and what your own selectors inherit, is in the notes below the table. |
Four logging features nebula-logger has that KernDX does not | nebula-logger and KernDX are equal on logging overall: both cover all eight logging capabilities we compared, equally well. nebula-logger goes deeper in four places: the choice of how each log is saved, seven log levels, a retention date per log entry or scenario (with purge), and archiving to a Big Object. We rated the two equal on how a log gets saved, but KernDX does not offer a choice of save method. nebula-logger also ships ready-made dashboards; on KernDX you build the same on LogEntry__c. What KernDX ships for logging is listed under the table. |
| Log delivery is best-effort | The logger is designed never to crash or roll back your business transaction, and the trade-off is that a log entry can be silently lost. If the platform-event publish fails, the most you get is a debug line visible only while an Apex trace flag is active, and a per-event rejection leaves no trace at all; per-event publish errors are not inspected, there is no retry and no fallback write to LogEntry__c, and a buffered flush clears the buffer whether or not the publish succeeded. A dropped log entry is therefore indistinguishable from no log entry. |
| Flow-as-trigger-action: typed-collection input shape | KernDX TRG_InvokeFlow ships with declarative failure-action custom metadata, a deploy-time scanner, a mock harness, and inherited recursion / perf / audit / feature-flag gating. taf covers the typed List<SObject> collection input shape that KernDX does not. The reason is a platform limit: Invocable.Action.setInvocations cannot pass typed collections to typed Flow inputs, so KernDX runs Flow actions one record at a time instead. It is a real gap, but not a reason to choose taf: KernDX covers everything else it does. |
| No retryable trigger actions | rflib supports Platform Event-based trigger retry (up to 8 retries), which KernDX does not. KernDX retry covers outbound HTTP calls and, as a choice you opt into, the individual steps of a background chain: a step can take a bounded number of attempts with a widening delay between them. Neither covers trigger handlers. |
| No fake for record writes in unit tests | KernDX fakes query results in tests (TST_Mock) and can build test records without saving them (TST_Builder.withoutInsertion()), but writes made by the code under test still reach the test database. apex-dml-mocking and apex-fluently-dml ship an in-memory fake for writes made through their own DML classes. If your team needs unit tests that never write records, that is the gap. |
| No general service layer or application factory | KernDX ships the domain layer (each object's business logic, kept in trigger actions you register in configuration rather than in a Domain class hierarchy) plus validation rules, and there it does as much as fflib. It deliberately does not ship a general service layer with an application factory, which fflib does, or a way for other packages to add selector fields and domain process steps, where at4dx goes furthest. If you require Domain-Driven Design with a service layer and an application factory, keep fflib or layer your own service layer on top of KernDX utilities. More under the table. |
Chain monitor controller selectors run in SYSTEM_MODE | The controllers behind the Chain Monitor and Event Monitor screens keep the SEL_Base defaults. When you switch off the permission and sharing checks on an individual QRY_Builder or DML_Builder call in your own code, the framework records it at runtime: the call that runs the query or DML writes a bypass audit entry per touched object, the same trace that handler bypasses leave. Framework-internal selectors such as these monitor controllers run in system mode by design, to read the framework's own records; this is not a bypass. |
| Namespace verbosity | Your code has to include the namespace prefix. Modern IDEs auto-complete this. |
Notes on the rows above:
- How the framework's own
SYSTEM_MODEselectors are checked (theSYSTEM_MODEselectors row): each of those selectors declares this in source, where git history and code review see it. The access-mode scanner that blocks the build in CI fails a build when a query or save written with the builders names no access mode; it does not look at selector reads, so code review is where these declarations are checked. - What your own selectors inherit (the same row): when you extend
SEL_Baseyou inheritUSER_MODEby default; opting out requires an explicit override. Emergency rollback is a metadata flip, no code deploy. - What KernDX ships for logging (the
nebula-loggerrow): four log levels on a single async transport, real-time log monitoring via Streaming Event Monitor, and the Log Console for browsing past entries (recurring problems grouped with occurrence counts, severity filtering, search, and a per-operation drilldown).LogEntry__cis fully queryable and masking-applied, for reports and dashboards you build. - Using
fflibbeside KernDX (the service layer row): KernDX's conventions cover selectors, trigger logic and saves. In those, your code extends KernDX's base classes rather thanfflib's. Anfflibservice layer and Application factory can sit beside it.
Modular Stack Risks
For balance, here are the risks that come with the other approach: assembling your own stack from separate libraries (taf + apex-fluently-soql + nebula-logger, and so on).
One note first: these modular-stack risks are scored on the same High-likelihood / High-impact scale that the Technical, Organisational, and Ecosystem Risks tables above use for KernDX. Neither approach is risk-free. Both stacks carry High-exposure risks, and the right choice depends on which set of risks your team is equipped to manage and which mitigations your team can sustain.
| Risk | Likelihood | Impact | Mitigation Feasibility | Net Exposure | Justification |
|---|---|---|---|---|---|
| Integration coherence degrades over time | High | High | Low | High | Independent release cycles; no cross-library consistency maintainer |
| Convention drift across libraries | High | Medium | Medium | Medium | 3-5 different API philosophies; no unified AI context file |
| Library code deployed as source in your org's analysis | Medium | Medium | Medium | Medium | The Apex of a library you deploy as source counts toward your org's 6 MB Apex limit and appears in your PMD code-quality scans and coverage reports. taf, apex-fluently-soql and nebula-logger each recommend installing them as unlocked packages instead |
| Upgrade coordination burden | Medium | High | Medium | Medium | 5+ independent release cycles; no single changelog |
| No single record of what ran across systems | High | Medium | Low | High | Tracing one user action across the separate libraries means writing the tracking code yourself |
| Documentation fragmentation | High | Low | Medium | Medium | No unified onboarding; must be written in-house |
| Abandoned library risk | Medium | High | Medium | Medium | Team inherits maintenance of unfamiliar source if maintainer stops |
Both approaches carry real risks. The right choice depends on which risks the team is equipped to manage.
What if the maintainer leaves?
"Bus factor" is the question every governance reviewer eventually asks: what happens if the one person who understands this disappears? This section answers it for KernDX honestly.
KernDX is single-maintainer today (see the date in the Metrics guide). This is acknowledged across several sections of this guide (Technical Risks, Organisational Risks, Enterprise Risk Dimensions), and it is not unusual for this kind of framework: most comparable Apex frameworks are also single-maintainer. Only the fflib project has several maintainers by the measures enterprise procurement teams typically use.
So the thing that actually matters is not how many maintainers a framework has. It is whether the maintainer's mental model is written down. A bus-factor event is survivable to the degree that the knowledge in someone's head has been moved into source-controlled documentation that a successor team can pick up cold.
KernDX documentation inventory (verifiable against this repo):
| Doc | Purpose | Size |
|---|---|---|
AGENTS.md | Tool-neutral entry point for AI coding assistants; points to the canonical conventions doc | 197 lines |
docs/Code Conventions - Guide.md | Canonical Apex/LWC/JS conventions: naming, sharing modifiers, testing patterns, framework idioms | 690 lines |
README.md | Project entry point: installation, getting started, references | 103 lines |
| Strategic Guides | Architectural decisions, adoption decisions, persona-tailored summaries, operations, risks, metrics, glossary | 9 documents |
docs/Security - Guide.md | Threat model, defaults, mitigations, bypass governance | 2,511 lines |
| Apex reference | Per-class API documentation auto-generated from ApexDoc on every release build (see Metrics for the page count) | one page per class |
Total Markdown documentation in docs/ | All .md files under the docs tree | 323 files |
You can verify this inventory yourself by running find docs/ -name "*.md" -type f | wc -l and wc -l AGENTS.md "docs/Code Conventions - Guide.md" README.md "docs/Security - Guide.md" at the released version.
What this means for a bus-factor event: A successor team encountering KernDX cold can read AGENTS.md + docs/Code Conventions - Guide.md + the relevant Strategic Guide + the Apex reference for the affected module and ship convention-compliant changes without prior KernDX experience. The mental model is in the repository, not in the maintainer's head.
The honest framing here is that bus-factor risk is structurally similar across most Apex frameworks today. KernDX accepts that, and competes only on the one thing that matters operationally: whether the codebase is documented well enough to be inherited. This guide makes no claim about the depth of any specific alternative framework's documentation; if you are comparing bus-factor exposure across frameworks, audit each candidate's repository documentation inventory directly.
Community Support: Signal vs Substance
A popular open-source project can look like a safety net, but "active community" and "someone will fix my production incident" are not the same thing. Most Salesforce open-source frameworks do not provide support backed by a service-level agreement (SLA), are maintained by small contributor groups, and do not guarantee production assistance. The table below separates what a community genuinely gives you from what it does not, so you do not mistake one for the other when scoring risk:
| Dimension | What Community Provides | What It Does Not Provide |
|---|---|---|
| Bug fixing | Shared issue visibility, community pull requests | Contractual resolution timeline |
| Knowledge | Public examples, Q&A, blog posts | Production firefighting |
| Longevity | Fork potential, shared ownership | Formal roadmap control |
| Hiring | Public maintainer-authored repos may surface in candidate portfolios, technical blogs, conference talks, and Trailhead modules | Deep expertise guarantee, or measurable hiring-pool depth for any specific framework |
- Public-maintainer-authored frameworks may give you shared issue visibility and community pull requests, but they do not guarantee shared maintenance. As covered in What if the maintainer leaves?, most comparable Apex frameworks are single-maintainer regardless of whether the source is publicly hosted.
- Open-source visibility does not remove your operational responsibility. Production firefighting still falls on you as the adopter, the same way it does for KernDX.
- Whatever framework you choose, your org has to own its operation.
This applies equally to all frameworks: open-source visibility and your own internal operational readiness are complementary, not interchangeable.
Governance Model
Who decides what goes into the framework, how you get help, and what keeps it alive if the maintainer steps away. This is what a procurement or governance team needs on record.
| Topic | Current State |
|---|---|
| Roadmap ownership | Primary developer with delivery engagement oversight |
| Contribution policy | Issues only: bug reports and feature requests are welcome; pull requests from outside contributors are not accepted yet |
| Support model | Engagement team during active projects; documentation + AI context for self-service post-handover |
| Escalation path | Delivery engagement lead then framework developer |
| Long-term sustainability | Open source under the Apache License 2.0, which ensures independence from any single maintainer; standard Apex patterns ensure any senior developer can maintain |
Versioning & API Stability
Whether an upgrade can break your code, and what KernDX promises to keep stable. The short answer: the global members are the stable part you build on, and breaking changes only land in a major version.
| Topic | Policy |
|---|---|
| Versioning strategy | Semantic versioning (major.minor.patch) on the released line |
| Backward compatibility | global API stability prioritised on the released line; breaking changes require major version bump |
| Current status | Packaged with 151 published managed-package versions declared in sfdx-project.json |
| Upgrade guarantees | Backward-compatible minor releases; breaking changes in major versions only |
| API stability | global members are the stable API; public members are internal and may change |
| Source delivery method | Public source repository under the Apache License 2.0; consulting engagements additionally include direct source delivery and handover support |
Adoption Gate Criteria
Any framework, whether integrated like KernDX or assembled from separate libraries, should meet these governance gates before enterprise adoption. Do not proceed unless every gate is PASS or CONDITIONAL, with explicit risk acceptance recorded for any FAIL gate. The table shows where KernDX stands today, including the gate it fails.
| Gate | Requirement | KernDX Status | Pass/Fail |
|---|---|---|---|
| G-1 | Semantic versioning documented | Committed for the released line (see Metrics for the versions) | PASS |
| G-2 | Backward compatibility guarantee | global API stability on the released line | PASS |
| G-3 | Deprecation lifecycle formalised | Planned, not formalised | FAIL |
| G-4 | Released in the 4 months before 2026-10-30 | Released in that window, including two releases in October 2026 (see Metrics) | PASS |
| G-5 | Named secondary maintainer | Single primary; succession via source ownership | CONDITIONAL |
| G-6 | Contribution guidelines published | CONTRIBUTING.md published in the source repository | PASS |
| G-7 | CI transparency | .github/workflows/ci.yml and Actions run history publicly visible on the source repository | PASS |
Assessment: KernDX passes 5 of 7 gates, with 1 conditional and 1 failure. G-4 uses the same rule as the comparison table below: at least one release in the 4 months before the comparison evidence was taken, 2026-10-30. If you adopt KernDX, document explicit risk acceptance for gate G-3 and establish contractual mitigations (source ownership, a defined handover process, succession planning).
The conditional G-5 gate ("succession via source ownership") is materially stronger in practice than the conditional label alone suggests. An AI coding tool can run the succession and exit path from the framework's public instruction files for AI coding tools, taking ~1-2 days of elapsed time for a deeply adopted transition. In other words, "succession via source ownership" fits in one sprint, not a multi-week project, for teams that use modern AI coding tools.
For comparison, the same gates applied to modular frameworks, read from each library's own repository as our evidence records it. The table scores the four libraries evaluators ask about most; the Choosing a Framework guide compares the rest.
One rule scores G-4 for all four, and for KernDX above: the gate asks whether the library has released at least once in the 4 months before the comparison evidence was taken, 2026-10-30. Salesforce ships three releases a year, so a library that goes longer without a release has missed a platform release. Our evidence records no published release schedule for any of these libraries, KernDX included, so the gate measures release activity instead. taf releases as package versions, not tags; its latest was on 2025-10-20, about a year before.
| Gate | taf | apex-fluently-soql | nebula-logger | fflib |
|---|---|---|---|---|
| G-1 Semantic versioning | FAIL (no published versioning policy or release notes) | PASS | PASS | FAIL (no version tags) |
| G-2 Backward compatibility | Not assessed‡ | Not assessed‡ | Not assessed‡ | Not assessed‡ |
| G-3 Deprecation lifecycle | FAIL (no upgrade or migration guide) | CONDITIONAL | CONDITIONAL | CONDITIONAL (a changelog of important changes) |
| G-4 Released in the 4 months before 2026-10-30 | FAIL (latest release 2025-10-20) | PASS (40 tagged releases, the latest in October 2026) | PASS (latest release v4.19.5, 2026-08-25) | FAIL (no versioned release; its one tag, from 2020-04-05, marks a change of source format) |
| G-5 Secondary maintainer | CONDITIONAL | CONDITIONAL† | CONDITIONAL | PASS (several maintainers) |
| G-6 Contribution guidelines | Not assessed‡ | Not assessed‡ | Not assessed‡ | Not assessed‡ |
| G-7 CI transparency | PASS | PASS | PASS | PASS |
† The 8 Apex Fluently libraries share a single primary author, so a full Apex Fluently stack is effectively a single-maintainer dependency (or two if paired with a separately-maintained logger such as nebula-logger), so an architecture board evaluating the modular stack as a whole should treat its overall G-5 gate result as CONDITIONAL even though each individual library lists its own G-5 status.
‡ Not assessed: our evidence for these four libraries does not record whether they publish a contribution guide or a backward-compatibility promise, so this table does not score G-2 or G-6 for them. Check both in each library's repository before you rely on it.
Hard Questions Architecture Review Boards Will Ask
These are the questions a review board reliably asks about any framework, with KernDX's straight answer to each and a link to where the detail lives. Take them into the room.
The eight questions, with KernDX's answer to each
| # | Question | Answer |
|---|---|---|
| 1 | What happens if the primary developer is unavailable? | KernDX is open source under the Apache License 2.0 on the project repository, so any team can clone, fork, and self-maintain regardless of vendor status, with consulting engagements including direct source delivery and handover support. For critical bugs, metadata-driven bypass mechanisms (TRG_Base.bypassAction(), FeatureFlag__mdt) isolate faulty handlers without code changes; the shipped repackaging-under-client-namespace tooling supports deeper fixes by forking the source under your own namespace. The AI-context files are described under the table. See Bus Factor Mitigation. |
| 2 | Can we mix modular components with KernDX later? | Yes. KernDX coexists with taf, apex-fluently-soql, and nebula-logger. See Coexistence Playbook. |
| 3 | What is the rollback strategy? | Three exit paths: continue managed package, deploy as source, or repackage under client namespace. Estimated ~1-2 days when done by an AI coding tool working from the framework's instruction files for AI coding tools, or 1-2 weeks done by people alone, for deeply adopted orgs. See Exit and Reversibility Analysis. |
| 4 | How do we validate production-scale performance? | Pre-compiled managed package; benchmark hot paths in sandbox. Per-trigger overhead has not been measured against a direct-Apex control arm, so KernDX publishes no overhead figure: measure your own hot paths before committing to one. See Performance & Governor Limits. |
| 5 | How does this affect hiring flexibility? | KernDX uses standard Apex patterns (selectors, triggers, DTOs). The ramp gap for an incoming developer is per-module API familiarity, not a language or paradigm shift, so any senior Apex developer can ship convention-compliant code after working through the relevant Fast Start. The hiring market is covered under the table. Each KernDX module has a timed, guided Fast Start and ApexDoc in your IDE (see Onboarding Time Comparison; its columns are not measured alike: KernDX's is timed on a guided path, the others are estimates from reference pages). |
| 6 | What governance gates must KernDX pass before adoption? | 7 gates defined. KernDX currently passes 5 of 7, with 1 conditional and 1 failure. Document explicit risk acceptance for any FAIL gate before you adopt. See Adoption Gate Criteria. |
| 7 | What if KernDX is abandoned? | Source ownership means clients can fork and maintain. Standard patterns mean the codebase is readable without framework expertise. Exit playbook in Migration Checklists. |
| 8 | How does KernDX map to a recognised security benchmark? | KernDX maps itself control-by-control against the Security Benchmark for Salesforce (54 controls across 12 domains): it provides a working mechanism or audit-ready evidence for 15 controls (peer review and static analysis, source-driven builds and secret scanning, masking detection and regulated-field inventory, plus the governance-evidence and access-review feeds), and is explicit that the other 39 are org configuration and process it does not own. |
More on two of the answers:
- AI-context files (the first question). They document framework conventions and patterns:
AGENTS.md(tool-neutral pointer) +docs/Code Conventions - Guide.md(the standard conventions) at the repository root carry instructions for AI coding tools, and the per-module AI Agent Instructions doc provides a deep framework reference. Developers using AI coding tools can generate convention-compliant code and diagnose framework internals without prior KernDX experience. This narrows, but does not close, the gap left by knowledge that lives only in people's heads. - The hiring market (the fifth question). This guide does not measure per-framework hiring-market depth for KernDX or for any alternative, so a claim that one specific framework is "easier to hire for" is not something you can rely on without your own historical data.
Strategic Recommendations
These are the risk-mitigation steps to take at each stage of adoption: before, during, and after. They matter most when your delivery runs on partner teams (systems integrators, SI) whose engineers rotate at every release. In that setting these steps double as operational controls that keep production safe through the build pipeline rather than through any one engineer remembering to be careful. The 100% per-file Apex coverage gate, the default-on data-access governance, and the audit-trailed bypasses act like a technical lead built into source-visible defaults, rather than living in a single engineer's memory.
Pre-Adoption:
- Run a time-boxed pilot (2-4 weeks) on a single non-critical object
- Assess exit cost: review Migration Checklists for migration effort
- Verify team readiness: at least one developer has reviewed the Fast Start guides
- Compare in sandbox: build the same feature with KernDX and a modular stack, then measure time, coverage, and satisfaction
During Adoption:
- Start with triggers and selectors: highest value, lowest risk
- Add web services and resilience when integration requirements arise
- Document all custom metadata configuration
- Maintain exit readiness
Post-Adoption:
- Assign a platform engineering owner for upgrades, log monitoring, and incident response
- Review quarterly: measure success metrics (see Success Metrics)
- Maintain AI context files: update
docs/Code Conventions - Guide.mdwhen conventions evolve - Ensure at least two team members can troubleshoot independently