This manual is for IT-FPX4079 Assessment 3, start to submission. The final deliverable in Python Scripting usually asks the program to do something a person would otherwise do by eye: take two exports that should agree, work out where they do not, and produce a report somebody can act on. Correctness stops being obvious at that point, because the program can run cleanly and still be wrong about which records matched. The criteria respond by asking for testing, for a stated matching rule, and for a report that a reader outside the technology team could use. Below is the method our tutors use for it, a structure that maps to the criteria, and an annotated sample excerpt. Prefer to hand it off? A premium original sample for this exact assessment comes back in 24 to 48 hours, revised free until it meets the guide. Your courseroom may print this as IT FPX 4079 Assessment 3 or IT4079 Assessment 3; it is the same deliverable, and IT-FPX4079 Assessment 3 is what this manual walks through.
One honesty note before the manual: Capella revises courses and scoring guides over time, so always write to the exact scoring guide attached to your assessment in the courseroom. The course identity above is verified on capella.edu; the method and structure below are our tutors' approach to it, not Capella's official rubric text.
How IT-FPX4079 Assessment 3 is scored
Each criterion lands at one of four levels rather than earning points, and the language of the level you are aiming for is the clearest instruction in the courseroom:
| Level | What it means on a reconciliation script |
|---|---|
| Distinguished | The matching rule is stated and defended, the tests prove correctness on cases worked out by hand, and the report names an action for each discrepancy class. The extra move sits in the criterion wording; go and take it. |
| Proficient | A program that reconciles the two sources correctly and reports the differences. Capable work that has not yet shown how correctness was established. |
| Basic | A script that prints a difference count, with the matching logic left implicit and the output left for a human to interpret. |
| Non-performance | A required element is missing, most often the testing or the documented matching rule. Absence decides the row without reference to anything else. |
When the numbers look wrong, stop editing and start narrowing. Cut the input to a handful of records you can verify by hand, work out the right answer manually, then print intermediate values until the program and your arithmetic part company. Keeping that small test file and mentioning it is what turns a fixed bug into a graded criterion.
The IT-FPX4079 Assessment 3 method, step by step
-
Write the matching rule down before you write the join
Two exports agree on nothing by accident. Take a bicycle manufacturer comparing an asset register export against a patch-management export: are you matching on hostname, on serial number, or on both with a fallback? Say which field is authoritative, what happens to case and whitespace differences, and what a duplicate means. An unstated rule is the defect that produces a plausible wrong answer.
-
Normalize on the way in, once
Trim, case-fold, and strip the domain suffix in the loader rather than at every comparison, so the rest of the program works with clean keys and the rule lives in one place. Record in the document what normalization you applied, because a reader reproducing your counts will get different numbers if they do not know that HOST01 and host01.corp.local were treated as the same machine.
-
Classify the discrepancies, not just count them
With 1,180 rows in the asset export and 1,043 in the patch-management export, the interesting output is not the 137 difference but the breakdown: assets absent from patch management, patch-management entries with no asset record, and rows present in both with conflicting attributes. Three classes, three different remedies, and a report that merges them is a report nobody can act on.
-
Test against answers you worked out by hand
Build a small pair of files with a known correct outcome: one clean match, one case difference, one duplicate, one record present on each side only. Run the program and compare against your own arithmetic. Off-by-one slices, strings never converted to numbers so comparisons run alphabetically, and counters reset in the wrong scope are where defects in this kind of program actually live.
-
Write the report for the person who has to act
Totals at the top, then each discrepancy class with a count, a few example rows, and the action it implies. Write to a file as well as to the screen so the result can be attached to a ticket, and format the file as something a spreadsheet opens. A report that requires the author present to interpret it has not met the communication criterion.
-
Map the criteria and self-score
Quote each criterion in the document and name the function, the test, or the output section that satisfies it. Then place every row at D, P, B, or N honestly, revise whatever falls short, and submit early because a FlexPath evaluation can take two business days and a late-week upload can wait out the weekend.
A structure that maps to the criteria
The counts below are how our tutors plan the written part of a reconciliation submission rather than a Capella rule; code and output sit outside them.
| Section | What it must do | Guide |
|---|---|---|
| Problem and sources | What the two exports contain, where each comes from, and what agreement between them would mean. | ~200 words |
| Matching rule | The key fields, the normalization applied, the treatment of duplicates, and why that rule is the right one. | ~300 words |
| Design | Loading, normalizing, comparing, classifying, and reporting as separate functions with stated responsibilities. | ~300 words |
| Testing | The small fixtures used, the expected result worked out by hand, and what each test proves. | ~300 words |
| Report and output | The totals, the discrepancy classes, the action attached to each, and the file the program writes. | ~250 words |
| Criterion map and sources | The function or test answering each criterion, plus any documentation cited in current APA. | ~150 words |
Annotated sample excerpt
One original model passage from our team, written at the level the top column describes. Read it for how it commits to a rule, then commit to yours.
Records are matched on serial number where both exports carry one, because the asset register treats serial as its primary key and hostnames are reassigned when a machine is reimaged, which makes hostname a weaker identifier than it looks.1 Where a serial is absent from the patch-management export, the program falls back to a normalized hostname produced by case-folding and removing the domain suffix, so that HOST01 and host01.corp.local resolve to the same key, and every fallback match is flagged in the output as lower confidence.2 Two rows sharing a key are reported as a duplicate rather than silently overwritten, since a duplicate in an asset register is itself a finding worth someone's attention and the count of machines would otherwise be quietly wrong.3
- 1Names the key and the reason the obvious alternative is weaker. A criterion asking about approach wants a defended choice, not a described one.
- 2Documents the normalization exactly, then marks the weaker matches instead of hiding them among the strong ones. Reproducibility and honesty in one sentence.
- 3Refuses to let a data problem disappear into a data structure. The decision to surface duplicates rather than overwrite them is the judgment being graded.
The full premium sample for your exact assessment, written fresh to your scoring guide and issue, is free to request. Study it, revise it into your own voice, and submit work you understand.
The five mistakes that cost Distinguished
- A matching rule left implicit in the code. A reader who cannot see the rule cannot check the counts, and the counts are the whole deliverable.
- Normalization applied at the comparison. Cleaning keys in several places is how two functions end up disagreeing about whether a record matched.
- Discrepancies reported as a single number. One total covers three different problems with three different remedies and helps nobody choose.
- Duplicates silently overwritten. The dictionary keeps the last row, the count comes out wrong, and nothing in the output admits it happened.
- Testing asserted rather than shown. Without a fixture and an expected answer, a claim that the logic was verified is an opinion about the code.
Pre-submission checklist
- The matching rule names its key fields, its normalization, and its treatment of duplicates
- Normalization happens once, in the loader, and is described in the document
- Discrepancies are reported by class, each with a count and an implied action
- At least three fixtures with hand-worked expected results are included and explained
- The program writes a file a spreadsheet can open as well as printing a summary
- Every criterion is tied to a function, a test, or an output section, then self-scored
Reconciliation script due and the counts will not settle?
Send both export formats, the prompt, and the criteria. A premium original returns inside 24 to 48 hours with a defended matching rule, classified discrepancies, fixtures with hand-checked answers, and a report somebody outside the team could act on. First sample free.