AWS Builder Center
Inside cfn-lint: Fixing Required-Parameter Schemas, Unknown Comparisons, and SAM Dependency Graphs

Inside cfn-lint: Fixing Required-Parameter Schemas, Unknown Comparisons, and SAM Dependency Graphs

An implementation-level deep dive into three merged cfn-lint fixes: E2900 required-set construction, cfnGather uncertainty propagation, and E3004 SAM graph filtering. Includes Python/YAML examples, edge-retention rules, regression matrices, and the open fallback-coverage follow-up.

A linter is most useful when its findings match what the infrastructure actually means. Missing a required parameter can let an incomplete deployment configuration pass. Reporting a circular dependency that disappears after a transform can send a developer debugging the wrong problem. And treating an unavailable resource property as a known value can turn uncertainty into a misleading error.
In this contribution series, we worked on all three problems in  cfn-lint , the open-source CloudFormation linter. The work touched parameter-schema construction, cross-resource property comparisons, and the dependency graph used by the circular-dependency rule.
The common goal was straightforward: report errors supported by the template, preserve checks for genuinely invalid configurations, and be explicit about what static analysis cannot determine.
This article walks through the problems, the implementation decisions, and the regression tests. Contribution status is current as of 22 October 2026.

What I Contributed

Contribution
Problem addressed
Status
 PR #4753 
Only the last required deployment parameter was checked
Merged
 PR #4754 
Unresolved gathered properties caused false SQS and RDS findings
Merged
 PR #4755 
SAM dependency cycles could be falsely reported or missed
Merged
 PR #4827 
Missing regression coverage for SAM dependency-graph fallback paths
Open; tests only
All three fixes merged on 21 October 2026 in IST. The parameter and gathered-property fixes merged on 20 October in UTC; the SAM fix merged on 21 October in UTC.

The implementation boundaries

These fixes operate at three different points in the validation pipeline:
Template parameter declarations + deployment parameter set
-> deployment_files/Parameters.py::_build_schema
-> required-property validation (E2900)

Resource properties + cross-resource references
-> cfnGather + resolve_data_in_schema
-> composite-schema evaluation with unknown results
-> _validate_gathered -> remapped resource findings

Template references and DependsOn
-> Graph(networkx.MultiDiGraph)
-> CircularDependency::_dependency_graph
-> Graph.get_cycles -> E3004 RuleMatch objects
The parameter patch changes schema construction. The gathered-property patch changes how unresolved comparison values enter the existing validator. The SAM patch changes the graph supplied to the existing cycle detector. Keeping those boundaries separate made the changes easier to reason about and review.
The code excerpts below are either short extracts from the linked changes or explicitly marked explanatory pseudocode. The graph and schema explanations describe the implementation inspected for this article, rather than claiming a complete formal model of CloudFormation deployment.

1. Checking every required deployment parameter

The first issue was small in code size but important in behavior. When deployment parameter values were supplied to cfn-lint, a template containing multiple parameters without defaults could pass validation even though one was missing. The result depended on parameter declaration order.  Issue #4752  captured the asymmetry.
Consider this template:
Parameters:
A:
Type: String
B:
Type: String
Resources:
Topic:
Type: AWS::SNS::Topic
Properties:
TopicName: !Sub '${A}-${B}'
Both parameters are required because neither has a default. Before the fix, the reported reproduction behaved differently for these two commands:
cfn-lint template.yaml --parameters B=b
cfn-lint template.yaml --parameters A=a
Supplying only  B  could pass, while supplying only  A  correctly reported that  B  was missing. Neither configuration supplied everything the template required.

Root cause: replacing a collection instead of accumulating it

The deployment-parameter rule builds a JSON Schema from the template's parameter declarations. While iterating over parameters without defaults, it replaced the required-parameter list:
schema["required"] = [parameter_name]
Each assignment discarded the earlier names. After the loop, only the final required parameter remained. We changed the operation to append to the existing list:
schema["required"].append(parameter_name)
That one-line change restored the intended behavior: every parameter without a default contributes to the required set.

Testing the behavior, including declaration order

The regression test covers four input combinations: neither parameter supplied, only  A , only  B , and both. Each runs in both declaration orders, producing eight cases. A parameter with a default sits between the required parameters to verify that it remains optional.
The assertions compare the complete set of missing-parameter messages. This checks both sides of the contract: missing required values are reported, and supplied or defaulted values do not produce those errors. The implementation and tests are in  PR #4753 .
The broader lesson is useful beyond CloudFormation: if reordering equivalent input changes validation, inspect how the validator accumulates state.

The invariant behind the one-line patch

Let  P  be the valid parameter declarations,  R  the names whose declarations lack a  Default  key, and  S  the names in the supplied deployment parameter set. The presence-validation invariant is:
R = {name in P | 'Default' is absent from P[name]}
missing = R - S
Before the patch, each loop iteration assigned a singleton list, so the generated schema effectively represented only the last visited member of  R . After the patch, the list accumulates every member. This is a key-presence test, not a truthiness test: an empty-string default is still a declared default.
The intended missing-name sets are independent of iteration order:
Supplied names
Expected missing names
none
A, B
A
B
B
A
A, B
none
The regression uses  ParameterSet(source=None, parameters=provided)  in an evolved validator context, invokes the rule, and compares the set of error messages with the expected set. Reversing the declaration dictionary tests permutation invariance; comparing sets avoids accidentally requiring a particular diagnostic order. This patch concerns presence validation for supplied deployment parameter sets, not a new requirement to supply all values for every template-only lint invocation.

2. Preserving uncertainty in cross-resource comparisons

The second problem involved rules that compare properties across resources. For example, cfn-lint checks the compatibility of an SQS source queue and its dead-letter queue. RDS rules also compare instance properties with properties of the referenced cluster.
These checks use  cfnGather  to collect values and  $data  references to compare them. That works when the referenced resource and the relevant property can be resolved from the template. An external resource identified by a literal ARN or name is a different case: its properties may not be available to the linter.
 Issue #4747  demonstrated false findings for SQS dead-letter queue references and RDS cluster identifiers, as well as a remote property represented by an intrinsic function.

Root cause: comparing a value with an unresolved instruction

Conceptually, a gathered-property schema can contain a comparison like this:
{
"const": {"$data": "/cluster/Engine"}
}
The  $data  object describes where to obtain the comparison value. It is not itself a database engine value. Previously, when lookup failed, the resolver could return that unresolved object. A known local value was then compared against the object rather than against a resolved remote value.
This produced false findings from  E3502 ,  E3707 , and  E3709 . Some RDS messages even exposed the unresolved  $data  object as the expected value.

The fix: represent an unknown comparison explicitly

We changed failed lookups to return the internal  _UNRESOLVED  sentinel. Schema resolution then marks an unresolved comparison with  cfnUnresolved . Deployment-time intrinsic values are also treated as unknown for these comparisons unless the schema explicitly requests literal comparison of the function objects.
The important design decision was to preserve that uncertainty through the rest of validation. Simply removing an unresolved constraint would be insufficient. A schema containing  not ,  if / then , or  oneOf  could interpret the remaining schema as a definite result and make an incorrect decision.
The new keyword yields a validation result marked  unknown=True . The gathered-property validation layer does not emit these unknown results as ordinary findings. This allows the schema machinery to carry uncertainty through composite checks instead of treating missing information as proof of a mismatch. See  PR #4754 .
This does not verify the actual configuration of an external resource. It avoids claiming a particular incompatibility when the required comparison value is unavailable.

Known values and real mismatches still matter

We added controls to ensure the fix did not silence useful findings:
  • A known in-template standard-to-FIFO SQS mismatch still produces the specific queue-type error.
  • Known RDS engine and encryption mismatches still produce their respective findings.
  • At the schema-resolver boundary, resolved values such as  False ,  0 ,  None , and an empty string remain known values rather than failed lookups.
  • An explicit  cfnContext  request for literal intrinsic-function comparison remains supported.
  • Composite-schema tests cover negation, conditionals, and  oneOf  with unavailable remote values.
The PR records 547 focused tests passing. The central distinction is between a value that is known and false-like, and a value that cannot be resolved. Those are different states, and a validator needs to preserve the difference.

Tracing the resolution failure precisely

At the resolver boundary, these inputs have different meanings:
schema = {"const": {"$data": "/target/value"}}

# A resolved scalar: retain the comparison.
resolve_data_in_schema(schema, {"target": {"value": False}})
# -> {"const": False}

# An absent property: preserve uncertainty.
resolve_data_in_schema(schema, {"target": {}})
# -> {"cfnUnresolved": True}

# A deployment-time function object: unknown by default.
resolve_data_in_schema(
schema, {"target": {"value": {"Ref": "Parameter"}}}
)
# -> {"cfnUnresolved": True}
For the  $data  path, the resolver traverses dictionaries by key and lists by integer index. Missing keys, invalid indexes or index conversions, and a non-container encountered before the end of the path return  _UNRESOLVED . The sentinel is tested with identity ( is ), so an actual resolved  False ,  0 ,  None , or empty string is not conflated with lookup failure. The  None  assertion here is specifically a resolver-unit-test contract; it is not a claim that every resource-property gathering path treats null identically.
The critical production branch is:
resolved = resolve_data_reference(v, root_instance)
if resolved is _UNRESOLVED:
result["cfnUnresolved"] = True
continue
if not allow_intrinsics and is_function(resolved)[0] is not None:
result["cfnUnresolved"] = True
continue
This behavior applies to the resolver's supported data-dependent keywords, which include  const ,  enum ,  pattern , numeric bounds, and length/item-count constraints. It is not a generic claim that every object-valued schema entry is unresolved.

Why dropping the constraint would be incorrect

Consider an unavailable remote value under negation:
{"not": {"const": {"$data": "/remote/value"}}}
Deleting the unresolved  const  would leave  not: {} . The empty schema accepts an instance, so negating it rejects the instance. A missing value would have manufactured a definite failure. Under  if , the empty condition could select  then ; under  oneOf , deleting a constraint could change the number of apparently matching branches.
The patch instead registers an internal keyword that yields an unknown result:
def cfnUnresolved(validator, value, instance, schema):
yield ValidationError(
"Cannot resolve gathered schema value", unknown=True
)
This connects the unresolved reference to cfn-lint's existing composite-keyword handling. A useful local model is three outcomes: proven match, proven mismatch, and unknown. It is not equivalent to silently making an unknown branch pass.
Composite keyword
Relevant handling in the inspected implementation
 not 
An unknown child produces an unknown result instead of being inverted into a definite answer
 if 
An unknown condition propagates uncertainty instead of choosing  then  or  else 
 oneOf 
With an unknown branch and fewer than two known matches, the result remains unknown; two known matches already prove failure
 anyOf 
A known matching branch is sufficient; otherwise unknown branches prevent a definite all-branches-failed result
At the gathered-validation boundary,  if err.unknown: continue  suppresses these indeterminate results as user-facing findings. Other errors still follow the existing path-remapping logic, which maps gathered entry/property paths back to template resource properties.
The literal-function escape hatch is also explicit. If a  cfnContext  sets  functions: [] , recursive schema resolution allows structural comparison of an intrinsic object. That preserves checks where comparing two references themselves is intentional, rather than attempting to compare their deployment-time values.

3. Evaluating SAM dependency cycles on the right graph

The most involved fix addressed  E3004 , the circular-dependency rule.
AWS SAM resources are abstractions over generated CloudFormation resources. A function definition can produce more than one resource, depending on its properties. That means a reference written inside a SAM resource does not always describe a dependency of its underlying Lambda function. AWS documents these mappings in  Generated CloudFormation resources for AWS SAM .
 Issue #4749  showed how the existing handling of SAM edges could fail in opposite directions.

Why filtering findings after cycle detection was too late

The previous rule found cycles in the original graph, then skipped reported edges whose source or target was an  AWS::Serverless::*  resource.
That left two problems:
  1. A cycle caused by a property that SAM moves to a separate generated resource could still produce a finding on the cycle's non-SAM edges.
  1. A real cycle between a SAM resource and a native resource could disappear from the findings because both edges touched the SAM resource.
Removing individual findings after discovering a cycle does not establish whether the cycle exists in the dependency model we actually intend to validate.

Three fixtures made the intended behavior concrete

The issue supplied three templates, which became regression fixtures:
Scenario
Earlier behavior reported in the issue
Expected behavior
Function deployment-preference alarms formed an apparent cycle
A non-SAM edge was reported
No E3004 finding for that apparent cycle
API access-log configuration formed an apparent cycle
A non-SAM edge was reported
No E3004 finding for that apparent cycle
Function environment referenced a table that depended on the function
The real cycle was missed
Report the circular dependency
The third case is especially useful because it prevents a false-positive fix from becoming a blanket exemption for SAM templates. Here is the essential reproduction, with descriptive logical IDs:
Transform: AWS::Serverless-2016-10-31
Resources:
Worker:
Type: AWS::Serverless::Function
Properties:
Runtime: python3.12
Handler: index.handler
InlineCode: 'def handler(event, context): return 1'
Environment:
Variables:
TABLE: !Ref DataTable
DataTable:
Type: AWS::DynamoDB::Table
DependsOn: Worker
Properties:
KeySchema:
- AttributeName: pk
KeyType: HASH
AttributeDefinitions:
- AttributeName: pk
AttributeType: S
BillingMode: PAY_PER_REQUEST
The function needs the table through  Ref . The table explicitly depends on the function. Both dependencies are relevant, so the cycle must remain visible.

The fix: prepare the dependency graph before finding cycles

We introduced a separate graph for this rule's analysis. For templates containing SAM resources, the implementation copies the original graph, filters the relevant SAM-originating edges, and runs cycle detection on that graph. Other rules retain access to the original graph and template.
The filtering uses a mapping from supported SAM resource types to their underlying CloudFormation types. Provider schemas identify properties of those underlying resources, and explicit additional properties cover relevant SAM-specific dependencies. For example, a function's environment references and dependencies associated with its generated execution role need to remain represented.
The implementation also handles several details that a broad “ignore SAM” rule would miss:
  • Explicit  DependsOn  edges are retained.
  • Dependencies belonging to separate generated stages, events, or deployment-preference resources are not incorrectly assigned to the SAM logical ID.
  • Role-generation properties do not introduce dependencies when an explicit role makes those properties unused for role generation.
  • Property lookups are cached by resource type during graph construction.
  • Missing schemas and unmapped SAM types take a conservative fallback path.
The merged change is deliberately narrower than running a full SAM transform. It does not add an  aws-sam-translator  dependency, and it remains conservative about dependencies contributed solely by generated event resources. That boundary is documented in  PR #4755 .

The graph model: directed edges with provenance

 Graph  uses  networkx.MultiDiGraph , allowing self-loops and multiple edges between the same pair of resources. In this article,  A -> B  means that  A  depends on  B . References from  Ref ,  Fn::GetAtt , and  Fn::Sub , plus explicit  DependsOn , supply dependency edges. Edge metadata includes  source_paths , locating the originating expression within the source resource.
Provenance is essential because two edges with identical endpoints can have different meanings. A dependency from a function's  Environment  must not be treated like a dependency from  DeploymentPreference.Alarms  merely because both reference the same target.
The existing  Graph.get_cycles  implementation calls  networkx.find_cycle  from each resource and deduplicates returned edges. Our patch retains that detector. It does not replace it with a new strongly-connected-components algorithm or claim to enumerate every elementary cycle.

Why edge filtering and cycle detection do not commute

Let  G  denote the original graph and  P(G)  the graph after applying the rule's SAM edge policy. The required operation is cycle detection on  P(G) , not filtering selected edges out of cycle findings computed on  G .
The deployment-preference fixture makes the distinction visible:
Original template-reference graph:

Fn --DeploymentPreference.Alarms--> Aggregate
Aggregate --Sub--> ErrorsAlarm
ErrorsAlarm --Ref--> Fn

Old reporting filter:
discover the cycle, then suppress edges touching Fn
-> Aggregate -> ErrorsAlarm can still be reported

Graph prepared for E3004:
remove the Fn -> Aggregate edge from the SAM base-resource model
-> Aggregate -> ErrorsAlarm -> Fn is an acyclic path
The access-log fixture has the same structure:
Api --AccessLogSetting--> AccessLogGroup
AccessLogGroup --DependsOn--> ApiGatewayAccount
ApiGatewayAccount --DependsOn--> Api
 AccessLogSetting  belongs to the generated stage rather than the underlying  AWS::ApiGateway::RestApi . Removing that outgoing property edge before analysis prevents an apparent base-resource cycle. We do not synthesize the full generated stage in this patch.
For the real-cycle fixture, the relevant graph remains:
Worker --Environment.Variables.TABLE / Ref--> DataTable
DataTable --DependsOn--> Worker
 Environment  is a property of the underlying Lambda function, and  DependsOn  is explicit. Both survive filtering, so E3004 reports the cycle.

The edge-retention predicate

For each edge originating at a SAM resource, the helper examines its top-level source property and the allowed-property set for that resource type. In explanatory pseudocode:
for source, target, key, metadata in snapshot_of_edges:
if source_is_not_sam(source):
continue
path = metadata.get("source_paths", [])
if path == ["DependsOn"]:
continue

allowed = cached_properties_for(source_resource_type)
remove = (
unused_role_generation_property(source, path)
or len(path) < 2
or path[0] != "Properties"
or path[1] not in allowed
)
if remove:
analysis_graph.remove_edge(source, target, key)
The explicit edge key matters: a  MultiDiGraph  can have several dependencies between the same endpoints. The implementation removes the specific disallowed edge rather than indiscriminately removing the relationship. Iterating over  list(graph.graph.edges(keys=True, data=True))  also separates traversal from structural mutation.
The allowed set combines the underlying provider schema's property names with these SAM-specific additions:
SAM type suffix
Underlying CloudFormation type
Additional properties in the mapping
 Function 
 AWS::Lambda::Function 
 CodeUri ,  ImageUri ,  Policies ,  AssumeRolePolicyDocument ,  PermissionsBoundary ,  RolePath ,  Tracing 
 Api 
 AWS::ApiGateway::RestApi 
 DefinitionBody ,  DefinitionUri 
 HttpApi ,  WebSocketApi 
 AWS::ApiGatewayV2::Api 
 DefinitionBody ,  DefinitionUri 
 Application 
 AWS::CloudFormation::Stack 
 Location 
 SimpleTable 
 AWS::DynamoDB::Table 
 PrimaryKey 
 LayerVersion 
 AWS::Lambda::LayerVersion 
 ContentUri 
 StateMachine 
 AWS::StepFunctions::StateMachine 
 DefinitionBody ,  DefinitionUri ,  Role ,  Logging ,  Tracing ,  Policies ,  PermissionsBoundary 
Every suffix in the first column is under  AWS::Serverless:: . The code obtains the provider schema using  cfn.regions[0]  and caches the property set by SAM type for that helper invocation. This is the implementation's regional scope, not a claim of per-edge or all-region schema analysis.
For functions and state machines with an explicit  Role , edges originating from  Policies ,  AssumeRolePolicyDocument ,  PermissionsBoundary , or  RolePath  are excluded by the role-specific check. The presence of a  Role  key determines that branch. Dependencies from an actual explicit role reference are not blanket-suppressed.

Isolation and fallback semantics

There are two levels of copying:
graph = copy(original_graph)
graph.graph = original_graph.graph.copy()
The first creates a separate cfn-lint wrapper; the second creates a separate NetworkX graph structure before edges are removed. This is not a recursive deep copy of every nested metadata value. The helper only reads metadata and removes edges from the copy, so its non-mutation contract is narrower and testable. Templates without SAM resources return the original graph directly without constructing this analysis copy.
When a mapped provider schema is missing,  ResourceNotFoundError  is caught and an empty allowed-property set is cached. Because the SAM additions are applied inside the successful lookup path, they are not retained after that exception. An unmapped SAM type also receives an empty set, without querying the provider manager. In both cases, uncertain property-derived edges are removed, while explicit  DependsOn  edges and edges originating at native resources remain.
This fallback can leave some property-driven cycles undetected when schema knowledge is missing. The trade-off is explicit: the rule avoids asserting unsupported dependencies while preserving the dependencies it can justify. It is not a full expansion of SAM or a guarantee that every generated-resource cycle is detectable.
The added preprocessing consists of a graph copy, an edge traversal, and cached schema/property-set construction. That does not imply an end-to-end linear-time bound for E3004: the existing repeated cycle searches and deduplication still determine part of the total cost. No performance benchmark is claimed by these PRs.

Regression tests checked what must remain unchanged

In addition to the three original fixtures, the tests exercise independent cycles between native resources, function environment and execution-role policy dependencies, unused policies with an explicit role, and self-dependencies through  Ref ,  GetAtt ,  Sub , and  DependsOn .
They also assert that the original graph edges and template are unchanged after the rule runs. That matters in a linter where multiple rules inspect shared input: fixing one analysis should not silently alter another rule's view.
The PR records 15 focused tests passing, alongside broader suite validation. The three reported fixtures specifically expect zero E3004 findings for each apparent cycle and two findings for the real two-resource cycle.

4. Following the merged fix with fallback-path tests

The work continued after the SAM fix merged. Its hosted Codecov report showed 91.176% patch coverage, with two uncovered lines and one partially covered line in the new dependency-graph logic.
Those gaps corresponded to meaningful fallback behavior: a missing schema for an underlying resource and an unmapped  AWS::Serverless::*  type. We opened  PR #4827  to cover those paths. It changes tests only and remains open as of this article's status date.
The follow-up adds four parameterized combinations: each fallback path, with and without an explicit  DependsOn . The tests verify that uncertain property dependencies are discarded while explicit dependencies and independent native cycles still produce findings. They also check that failed schema lookups are cached, unmapped types do not trigger a provider-schema lookup, and the original graph object, graph edges, and template remain intact.
Validation recorded in the follow-up PR includes 19 focused SAM/circular-dependency tests, plus 3,107 passing unit/integration tests and 28 passing subtests on its stated main-branch baseline. Four data tests retain the repository's default exclusion; a separate data-format test and changed-file checks were also recorded as passing.
The local coverage reconstruction raised fully covered executable lines in the original #4755 patch from 31/34 to 34/34. That is a local result for the original patch, not a claim of 100% project coverage or a hosted Codecov result for the follow-up. Hosted verification was still pending in the PR description.

The four-case fallback regression matrix

The follow-up patches  PROVIDER_SCHEMA_MANAGER.get_resource_schema  at the lookup location used by  CircularDependency , with a  ResourceNotFoundError  side effect. It then varies resource type and the presence of an explicit dependency:
SAM source type
Explicit Sam -> Target DependsOn
Expected resources with E3004 findings
Schema lookup expectation
 AWS::Serverless::Function 
absent
First, Second
exactly one lookup for the Lambda schema
 AWS::Serverless::Function 
present
First, Second, Sam, Target
exactly one lookup for the Lambda schema
 AWS::Serverless::Unknown 
absent
First, Second
no lookup
 AWS::Serverless::Unknown 
present
First, Second, Sam, Target
no lookup
 First  and  Second  form an independent native-resource cycle in every case.  Target  always depends on  Sam ; adding  Sam.DependsOn: Target  closes a second, explicit cycle.  Sam  also has both environment and policy references to  Target , so the fixture exercises multiple uncertain property dependencies rather than only one edge.
 AWS::Serverless::Unknown  is a synthetic test type for the fallback path, not a supported SAM resource recommendation. The test invokes the circular-dependency rule directly; it does not assert that the entire synthetic template passes every cfn-lint rule.
The assertions check the resource set, the exact match count, the schema mock's call count and arguments, and these non-mutation conditions:
assert cfn.graph is original_graph
assert list(original_graph.graph.edges(data=True, keys=True)) == graph_edges
assert template == original_template
 graph_edges  is deep-copied before execution in the follow-up. That means an accidental change to nested edge metadata cannot be hidden by both the expected and actual lists referring to the same mutated object. The separate template snapshot catches mutation outside the graph.
The reported mutation controls deliberately introduced behavior such as re-raising a missing-schema exception, retaining unmapped property edges, or mutating the original graph. The new tests detected those controls. This is evidence that the assertions discriminate between the intended behavior and specific regressions; it is not a claim of exhaustive mutation testing.
For a checkout containing the relevant changes, the focused regression modules can be run from the repository root after following its development setup:
python -m pytest test/unit/rules/deployment_files/test_parameters.py
python -m pytest test/unit/module/jsonschema/test_cfn_gather.py \
test/unit/module/jsonschema/test_keywords_cfn.py \
test/integration/test_gather_references.py
python -m pytest test/integration/test_sam_cycles.py
The additional four fallback cases require the open #4827 changes. The commands identify the regression modules; they are not a claim that I reran the historical validation suites while writing this article. The suite counts above come from the validation records in the linked PRs, at their respective baselines.

What this contribution process reinforced

These changes had different implementations, but the same discipline helped make them reviewable.
Start with the smallest example that distinguishes correct from incorrect behavior. The parameter issue needed only two required parameters. The SAM issue needed both apparent cycles and a real cycle. Those examples gave the patch a precise target.
Keep a known failure beside every false-positive reproduction. Removing an erroneous SQS finding is only half the job; a known queue-type mismatch must still be detected. The same applies to SAM cycles and RDS comparisons.
Carry uncertainty deliberately. External identifiers, deployment-time intrinsics, and missing schemas are normal inputs for static analysis. Treating them as ordinary concrete values can produce confident but incorrect findings.
Build the right representation before applying the algorithm. For SAM, the important change was the dependency graph supplied to cycle detection. Filtering the resulting messages could not correct the underlying model.
Use coverage gaps to ask behavioral questions. The follow-up was valuable because it tested what happens when schema knowledge is incomplete, not simply because it improved a percentage. Its recorded control checks also verified that the tests catch regressions such as re-raising the missing-schema exception or mutating the original graph.
Thank you to the cfn-lint maintainers and the contributors who provided the issue reports and reproductions. Their work made it possible to turn narrowly described failures into focused fixes and regression tests.
For anyone starting an open-source contribution, a small validation bug is a worthwhile place to begin. A clear reproduction, an explanation of the root cause, and tests that preserve the surrounding behavior can make even a one-line change useful to the next developer who relies on the tool.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article