Grade 13 · a vocational technology learning center, by urbanicity

newSchoolWorks.com › VoTechWorks › Technology & Design › Data Science & Analytics › Courses

Technology & Design · course plan

⚠ Pending professional review

This course plan, its lessons and its assessments has not yet been verified by an industry-certified professional or by a certification or approval body. It is a study draft and may contain errors. Do not use it as instructions for work on a job site or on live equipment. Always follow your instructor, your supervising professional, and current official references and regulations.

VoTechWorks program approval and accreditation are still in progress. Credentials are issued only by the certifying bodies named in each program, after their own exams.

Data Science & Analytics

14 courses · 1,800 clock hours · 9–12 mo full-time. Grading is competency-based: each course requires the written exam, a competent skills demonstration with zero safety faults, a signed log, and a passed safety audit; percentage weights only rank performance above the competency floor.

~~$17,810~~ COMPLIMENTARYprogram tuition

14courses

109lessons

1,800hours

51assessments

Development progressPlanCourses, lessons and assessments written for this tradeLessons109 of 109 lesson pages writtenPractice871 practice questionsResources120 reference entries (study list)Review0 lesson pages reviewed by a licensed professional

Study now: 109 lesson pages are open (lesson titles below are links).

TEC-DATA85-01 Universal core

Universal Core: Safety, Math, Communication & Career for Data Science & Analytics

148 hr · ~~$1,185~~ COMPLIMENTARY

This foundational course establishes the safety, mathematical, communication, and professional skills every data science and analytics practitioner needs before touching real data or production systems. Learners complete OSHA 10-Hour General Industry training, applied trade math, technical reading and writing, digital workplace tools, and structured career-readiness activities. All content is contextualized to data environments — server rooms, office ergonomics, remote work, and professional data teams.

Outcomes

Demonstrate OSHA 10-Hour General Industry compliance knowledge and apply ergonomic and electrical safety practices specific to data computing environments.
Perform trade-relevant mathematical operations — including descriptive statistics, unit conversion, percentage change, index calculations, and basic probability — accurately without a calculator and with spreadsheet tools.
Read and interpret technical documentation, data dictionaries, schema diagrams, and professional style guides to extract and summarize key information.
Produce clear written and oral communications appropriate to data analytics contexts, including a professional email, a one-page technical summary, and a two-minute verbal data brief.
Configure and use digital workplace tools — file management systems, version control concepts, cloud storage, and productivity suites — as required in entry-level data analyst roles.
Develop a career portfolio foundation including a resume tailored to data analytics job postings, a LinkedIn profile, and a short professional bio.

Course text

How the course runs. 7 blocks: Workplace Safety in Data & Technology Environments: OSHA 10-Hour General Industry; First Aid, CPR/AED, and Emergency Response for the Technology Workplace; Trade Math for Data Analytics: Arithmetic, Percentages, Rates, and Index Numbers; Reading Technical Documentation: Data Dictionaries, Schema Diagrams, and API Docs; Technical Writing and Professional Communication for Data Analysts; Digital Workplace Tools: File Systems, Version Control Concepts, Cloud Storage, and Productivity Suites; Career Readiness: Resume, LinkedIn, Professional Bio, and Job-Search Strategy for Data Analytics.

What competent looks like. Demonstrate OSHA 10-Hour General Industry compliance knowledge and apply ergonomic and electrical safety practices specific to data computing environments. Perform trade-relevant mathematical operations — including descriptive statistics, unit conversion, percentage change, index calculations, and basic probability — accurately without a calculator and with spreadsheet tools. Read and interpret technical documentation, data dictionaries, schema diagrams, and professional style guides to extract and summarize key information. Produce clear written and oral communications appropriate to data analytics contexts, including a professional email, a one-page technical summary, and a two-minute verbal data brief. Configure and use digital workplace tools — file management systems, version control concepts, cloud storage, and productivity suites — as required in entry-level data analyst roles. Develop a career portfolio foundation including a resume tailored to data analytics job postings, a LinkedIn profile, and a short professional bio.

Lessons · 7 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Workplace Safety in Data & Technology Environments: OSHA 10-Hour General Industry	30	theory	Learners will identify OSHA General Industry hazard categories relevant to data workplaces — including electrical safety, ergonomics, emergency action plans, and fire prevention — and earn the OSHA 10-Hour General Industry card.	Complete all required OSHA 10-Hour General Industry modules (delivered through an OSHA-authorized provider or authorized online course), including hazard recognition exercises specific to server rooms, open-plan offices, and remote-work home offices. Conduct a paired ergonomic self-assessment of the classroom workstation using a standard ergonomic checklist: monitor height, keyboard position, lighting, cable management, and chair adjustment; document two corrective actions taken. Participate in a scenario-based group exercise in which teams identify electrical hazards (overloaded power strips, improper grounding, UPS units) in a mock data center floor plan and write a one-paragraph hazard report per OSHA Hazard Communication conventions.	OSHA 10-Hour General Industry authorized course materials; OSHA Publication 3151 (Ergonomics); classroom workstations; ergonomic checklist (instructor-provided); mock data center floor plan diagram; first-aid/CPR certification materials (American Red Cross or American Heart Association approved)	Learner presents valid OSHA 10-Hour General Industry completion card or certificate; passes provider-administered OSHA 10 final assessment at the provider's required passing score; scores ≥80% on instructor ergonomic-hazard identification quiz (10 items).
2	First Aid, CPR/AED, and Emergency Response for the Technology Workplace	8	lab	Learners will demonstrate hands-only CPR, AED use, and basic first-aid response procedures at the skill level required for certification by an accredited provider.	Complete a full American Red Cross or American Heart Association Adult CPR/AED skills session on manikins, including at least three full practice cycles with instructor feedback on compression rate, depth, and recoil. Perform a simulated AED scenario in pairs — one learner acts as a bystander, the other operates a trainer AED unit through the full power-on, pad-placement, shock-delivery, and post-shock CPR sequence. Role-play a data center emergency scenario (co-worker unresponsive at workstation) in which learners activate emergency response (call 911, retrieve AED), demonstrate compression-only CPR, and brief emergency responders using the SBAR format (Situation, Background, Assessment, Recommendation).	CPR manikins (adult); trainer AED unit; disposable manikin face shields; American Red Cross or AHA CPR/AED student manual; gloves (nitrile); scenario script (instructor-provided)	Learner passes the accredited provider's CPR/AED skills evaluation and receives a valid certification card; instructor observes and checks off correct compression depth, rate, and AED pad placement on a skills checklist (all critical steps must be demonstrated correctly).
3	Trade Math for Data Analytics: Arithmetic, Percentages, Rates, and Index Numbers	28	practice	Learners will accurately perform arithmetic, percentage, rate, ratio, and index-number calculations that appear routinely in data analytics workflows, including year-over-year change, per-capita rates, and weighted averages.	Work through a structured problem set of 40 items covering: integer and decimal arithmetic, fraction-to-decimal conversion, percentage change (absolute and relative), parts per thousand, ratios and proportions, weighted averages, and unit conversion (metric and US customary); items are drawn from realistic data analytics contexts such as population rates, sales KPIs, and sensor readings. Use a spreadsheet (Google Sheets or Microsoft Excel) to replicate the manual calculations from the problem set using formulas; compare results, identify and correct formula errors, and format outputs to two decimal places with appropriate units. Complete a timed 20-item 'data analyst math sprint' (no calculator, 25 minutes) simulating the numerical reasoning sections of CompTIA Data+ and similar credentialing exams; self-score and record error types in a reflection log.	Instructor-prepared problem set packet; scientific calculator; Google Sheets or Microsoft Excel; CompTIA Data+ Exam Objectives (current version) for math domain reference; Khan Academy arithmetic and statistics modules (supplemental)	Learner scores ≥80% on the timed 20-item math sprint without a calculator; spreadsheet exercise is graded for formula accuracy (all 10 required formulas must produce correct output).
4	Reading Technical Documentation: Data Dictionaries, Schema Diagrams, and API Docs	20	theory	Learners will extract and summarize key information from data dictionaries, entity-relationship (ER) diagrams, technical specifications, and API reference pages to answer specific analytical questions.	Read a two-page excerpt from a real public-sector data dictionary (e.g., a US Census Bureau or city open-data portal data dictionary) and answer a structured question set: identify field names, data types, units, null conventions, and any stated data quality limitations. Interpret a simplified ER diagram for a three-table relational database (customers, orders, products) and write a plain-language paragraph describing how the tables relate, what the primary and foreign keys are, and what analytical question the schema could answer. Skim a short public REST API reference page (e.g., from data.gov or a weather API) and complete a structured annotation: identify the base URL, one GET endpoint, required parameters, response format, and rate limits; present findings in a two-minute verbal summary to the class.	US Census Bureau data dictionary excerpts (public domain); sample ER diagram (instructor-provided); public API reference page (printed or on-screen); annotation worksheet; academic reading strategies handout (SQ3R method)	Data dictionary question set scored at ≥80% correct; ER diagram paragraph reviewed by instructor against a four-point rubric (accuracy of relationships, key identification, clarity, completeness — must score ≥3 on each dimension); verbal API summary checked against annotation worksheet.
5	Technical Writing and Professional Communication for Data Analysts	22	practice	Learners will compose a professional email, a one-page technical findings summary, and a two-minute oral data brief that meet the clarity, format, and audience-appropriateness standards expected in entry-level data analytics roles.	Analyze three sample data analyst emails (one strong, two with common errors — burying the ask, unexplained jargon, no actionable next step) using a provided rubric, then rewrite the two weak emails; peer-review rewrites using the same rubric. Draft a one-page technical summary of a provided two-page dataset findings report, translating statistical language into plain business English for a non-technical manager audience; use the provided one-page template with sections for key finding, supporting evidence, limitation, and recommended action. Deliver a two-minute oral data brief to the class using one slide or one printed chart, following the structure: context → finding → so what → next step; receive peer and instructor feedback on clarity, pacing, and avoidance of unexplained acronyms.	Sample email set (instructor-prepared); one-page summary template; provided two-page findings report (instructor-prepared from public data); Google Slides or PowerPoint; professional communication style guide (e.g., APA or Chicago author-date, instructor-specified); peer feedback form	Email rewrite scored ≥80% on a six-item rubric (clear subject line, one main ask, correct salutation/closing, no unexplained jargon, appropriate length, professional tone); one-page summary graded pass/fail against four required sections — all four must be present and accurate; oral brief assessed by instructor on a three-item checklist (structure followed, finding stated clearly, no unexplained acronyms) — all three must be checked.
6	Digital Workplace Tools: File Systems, Version Control Concepts, Cloud Storage, and Productivity Suites	22	lab	Learners will organize a multi-file data project using a standard folder convention, perform basic Git version-control operations (init, add, commit, push), and demonstrate proficiency with cloud storage and collaboration features of at least one productivity suite.	Set up a standardized project folder structure (raw data, processed data, notebooks, reports, documentation) for a provided sample project; rename files to a specified snake_case convention; create a plain-text README.md file describing the project, data source, and folder contents. Using Git (command line) and a free GitHub account, initialize a local repository for the sample project folder, stage and commit all files with a descriptive commit message, push the repository to GitHub, and make one deliberate edit followed by a second commit — demonstrating the edit-stage-commit cycle. Upload the project repository to Google Drive or Microsoft OneDrive, share it with a classmate with comment-only permissions, use the collaboration tools to leave two inline comments on the README, and resolve one comment — demonstrating cloud collaboration workflow.	Classroom computers with Git installed; GitHub free accounts; Google Drive or Microsoft OneDrive; VS Code or any plain-text editor; Pro Git (Scott Chacon & Ben Straub, free online) chapters 1–2; instructor-provided sample project files and README template	Instructor inspects GitHub repository: correct folder structure present, README.md complete, minimum two commits with descriptive messages — all three criteria must be met for pass; cloud share checked live: correct permission level set and at least one comment resolved.
7	Career Readiness: Resume, LinkedIn, Professional Bio, and Job-Search Strategy for Data Analytics	18	practice	Learners will produce a complete, industry-formatted data analytics resume, a filled LinkedIn profile, and a 150-word professional bio, and will articulate a three-step job-search strategy targeting entry-level data analyst roles.	Analyze two real entry-level data analyst job postings (sourced from Indeed or LinkedIn the week of class) using a keyword mapping worksheet: identify the five most repeated technical skills, two soft skills, and one credential mentioned; revise a provided draft resume template to reflect those terms authentically and correctly. Complete all major LinkedIn profile sections (headline, about, education, skills, featured section with GitHub link) using a profile-completion checklist; write a 150-word professional bio in third person suitable for a portfolio website, following a provided bio structure (name + current status → key skills → goal → call to action). Participate in a mock 10-minute informational interview in pairs, alternating roles of interviewer and candidate; candidate uses the STAR method (Situation, Task, Action, Result) to answer one behavioral question drawn from a bank of common entry-level data analyst interview questions; debrief with structured peer feedback.	Resume template (instructor-provided, plain .docx); two live job postings (printed or on-screen); keyword mapping worksheet; LinkedIn profile-completion checklist; professional bio template; STAR method reference card; O*NET Online entry for Data Analyst (15-2051.00); Bureau of Labor Statistics Occupational Outlook Handbook — Data Scientists entry (current edition)	Resume reviewed by instructor against a ten-item checklist (contact info, objective/summary, education, two or more relevant skills, consistent formatting, no spelling errors, tailored keywords from job posting, quantified bullet point, one-page length, saved as PDF) — must pass 9 of 10 items; LinkedIn profile checked against completion checklist — all required sections must be filled; bio reviewed for all four required structural elements.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
OSHA 10 & Safety Knowledge Exam	Written exam	25%	80% or higher on a 40-item multiple-choice exam; valid OSHA 10-Hour General Industry completion card must also be on file.	A 40-item multiple-choice exam covering OSHA General Industry hazard categories, ergonomic principles for technology workplaces, electrical safety, emergency action planning, and first-aid/CPR principles as taught in Lessons 1 and 2. Items are drawn from OSHA 10 content areas and adapted to data-center and office environments. Accuracy · Safety · Communication · Professionalism
Trade Math & Technical Reading Exam	Written exam	25%	80% or higher; learners must achieve at least 75% on the math section and at least 75% on the reading section independently — a combined average above 80% does not compensate for a section below 75%.	A 50-item exam in two sections: Section A (30 items) covers percentage change, rates, weighted averages, index numbers, and unit conversion as taught in Lesson 3, with a mix of calculation and multiple-choice items; Section B (20 items) presents short excerpts from a data dictionary and an ER diagram followed by comprehension and inference questions as taught in Lesson 4. This exam maps to the numerical reasoning and data concepts domains of CompTIA Data+. Accuracy · Safety · Communication · Professionalism
Career Portfolio Project	Project	25%	Pass requires all five deliverables submitted and each scoring 'meets standard' or higher on its rubric; any deliverable rated 'does not meet standard' results in a resubmit with one additional attempt within five business days.	Learners submit a complete career portfolio package consisting of: (1) a one-page data analytics resume tailored to a specific posted job, (2) a live LinkedIn profile URL with all required sections complete, (3) a 150-word professional bio, (4) a GitHub repository demonstrating correct folder structure and at least two meaningful commits, and (5) a one-page written technical summary translating a provided dataset finding for a non-technical audience. Each deliverable is scored against the rubric introduced in the corresponding lesson. Accuracy · Safety · Communication · Professionalism
Oral Professional Brief and Self-Reflection	Oral / panel	25%	Pass requires a score of 3 or higher on all four rubric dimensions (maximum 4 per dimension); a score of 2 or lower on any single dimension requires a repeat performance within five business days.	Learners deliver a five-minute oral presentation to a panel of at least one instructor and one invited industry guest or program advisor; the brief presents the learner's GitHub portfolio project, explains two safety or ergonomic practices they will apply on the job, demonstrates one trade math calculation relevant to their career goal, and closes with a 30-second professional self-introduction. The panel scores the brief on: content accuracy, clarity of communication, professional presence, and ability to respond to one follow-up question. Accuracy · Safety · Communication · Professionalism

TEC-DATA85-02 Trade course

Statistics for Data Science & Analytics

103 hr · ~~$1,235~~ COMPLIMENTARY

Students develop the statistical reasoning and computational skills needed to describe, analyze, and draw valid conclusions from real-world data sets used in data science workflows. Topics span descriptive statistics, probability, inferential methods, and regression, all applied using Python or spreadsheet tools on authentic data. Mastery of these concepts directly supports performance on the CompTIA Data+, Google Data Analytics, and IBM Data Science Professional credential exams.

Outcomes

Calculate and interpret measures of central tendency, spread, and shape for continuous and categorical data sets drawn from workplace contexts.
Apply fundamental probability rules and common distributions (normal, binomial, Poisson) to quantify uncertainty in data.
Construct and correctly interpret confidence intervals and perform hypothesis tests (z-test, t-test, chi-square) at stated significance levels.
Select and execute appropriate correlation and simple/multiple linear regression analyses, then evaluate model fit using standard diagnostics.
Identify and explain common statistical pitfalls—sampling bias, confounding, p-hacking, and misuse of averages—that affect data quality and decision-making.
Communicate statistical findings in plain language through annotated tables, charts, and a written summary that a non-technical audience can act on.

Course text

How the course runs. 9 blocks: Data Types, Measurement Scales, and Descriptive Statistics; Data Distributions and Visualization of Shape; Probability Fundamentals; Common Probability Distributions; Sampling Methods and the Central Limit Theorem; Confidence Intervals and Hypothesis Testing; Two-Sample Tests and Chi-Square Analysis; Correlation and Simple Linear Regression; Multiple Regression, Statistical Pitfalls, and Communication.

What competent looks like. Calculate and interpret measures of central tendency, spread, and shape for continuous and categorical data sets drawn from workplace contexts. Apply fundamental probability rules and common distributions (normal, binomial, Poisson) to quantify uncertainty in data. Construct and correctly interpret confidence intervals and perform hypothesis tests (z-test, t-test, chi-square) at stated significance levels. Select and execute appropriate correlation and simple/multiple linear regression analyses, then evaluate model fit using standard diagnostics. Identify and explain common statistical pitfalls—sampling bias, confounding, p-hacking, and misuse of averages—that affect data quality and decision-making. Communicate statistical findings in plain language through annotated tables, charts, and a written summary that a non-technical audience can act on.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Data Types, Measurement Scales, and Descriptive Statistics	10	theory	Students classify variables by type and measurement scale and compute measures of central tendency and spread by hand and in a spreadsheet.	Lecture and guided notes: nominal, ordinal, interval, ratio scales with trade examples (sensor readings, survey Likert items, revenue figures); students sort a card set of 20 variables into the four scale categories. Spreadsheet lab: given a 200-row municipal dataset (e.g., city inspection scores), students calculate mean, median, mode, range, variance, standard deviation, and IQR using built-in functions and verify two values by hand calculation. Small-group discussion: compare three real headlines that misuse averages (e.g., mean income vs. median income); each group writes a one-paragraph correction and presents to the class.	Microsoft Excel or Google Sheets, municipal open-data CSV (e.g., NYC or Chicago open data portal), whiteboard, scientific calculators, NIST/SEMATECH e-Handbook of Statistical Methods (online reference)	Exit quiz of 10 items: students must correctly classify 5 variables by scale and compute mean, median, and standard deviation for a small data set; pass mark 70%.
2	Data Distributions and Visualization of Shape	11	demo	Students construct and interpret histograms, box plots, and frequency tables to describe the shape, center, and spread of a distribution.	Instructor live demo: build a histogram and box plot in Python (matplotlib/seaborn) from a real wages dataset; students replicate each step in their own Jupyter notebooks. Lab exercise: students load a provided CSV of daily ride-share trip durations, choose appropriate bin widths, generate side-by-side box plots split by day of week, and annotate outliers. Written reflection (one page): students describe the shape of their distribution (symmetric, left-skewed, right-skewed), explain what skew means for the mean vs. median, and note any data-quality concerns they observe.	Jupyter Notebook, Python 3 with pandas, matplotlib, seaborn; ride-share open dataset (e.g., Chicago TNC trip data); Anaconda or cloud-based JupyterHub	Instructor reviews notebook output; students must produce correctly labeled histogram and box plot and correctly identify distribution shape and outlier direction; pass mark 70% on a 10-point rubric.
3	Probability Fundamentals	11	theory	Students apply the addition rule, multiplication rule, and conditional probability to calculate event probabilities in data-context scenarios.	Lecture with worked examples: sample spaces, events, complement, union, intersection, mutually exclusive vs. independent events; students complete 8 guided practice problems on probability of combined events using a defective-products scenario. Card and dice simulation: pairs of students run 50 trials of a two-event experiment, record observed frequencies, compare to theoretical probabilities, and compute the absolute difference; class data is pooled in a shared spreadsheet. Conditional probability case study: given a contingency table of loan approvals by applicant category, students compute P(approved \| category) for each group and discuss implications for algorithmic fairness (previewing the Ethics & Privacy course).	Standard playing cards, six-sided dice, shared Google Sheet, printed contingency table handout, OpenIntro Statistics (free PDF, Diez et al.) Chapters 2–3	10-item in-class probability quiz; students must correctly apply at least one of each rule type (addition, multiplication, conditional); pass mark 70%.
4	Common Probability Distributions	12	demo	Students identify when to use normal, binomial, and Poisson distributions and calculate probabilities and quantiles using tables and Python's scipy.stats.	Instructor demo: parameterize and plot normal, binomial, and Poisson distributions in Python using scipy.stats; annotate each plot with mean and standard deviation; students replicate with their own parameter choices. Problem set (12 problems): given realistic scenarios (server error counts per hour, proportion of defective units, delivery time), students identify the appropriate distribution, state parameters, and compute the requested probability. Empirical vs. theoretical comparison lab: students generate 1,000 random samples from a normal distribution in Python, plot the empirical histogram, overlay the theoretical PDF, and compute the percentage of values within one, two, and three standard deviations.	Jupyter Notebook, scipy.stats, numpy, matplotlib; z-table and binomial table handouts; OpenIntro Statistics Chapter 4	Problem set graded by instructor; students must correctly identify distribution and compute probability for at least 9 of 12 problems; pass mark 75%.
5	Sampling Methods and the Central Limit Theorem	11	lab	Students demonstrate the Central Limit Theorem through repeated sampling simulation and explain how sample size affects the sampling distribution of the mean.	Guided Python simulation: students draw 1,000 samples of sizes n=5, 30, and 100 from a skewed population distribution, compute the sample mean for each draw, and plot all three sampling distributions side by side to observe convergence to normality. Sampling methods comparison: instructor presents simple random, systematic, stratified, cluster, and convenience sampling; students design a sampling plan for a hypothetical city-health survey, justify their choice of method, and identify one bias risk. Written lab report (one to two pages): students state the CLT in their own words, present their simulation plots with captions, and explain what the results mean for choosing sample sizes in real projects.	Jupyter Notebook, numpy, matplotlib, seaborn; city-health survey scenario handout; OpenIntro Statistics Chapter 5	Lab report graded on a 10-point rubric: correct simulation code (4 pts), accurate plot interpretation (3 pts), coherent CLT explanation (3 pts); pass mark 70%.
6	Confidence Intervals and Hypothesis Testing	14	lab	Students construct 90%, 95%, and 99% confidence intervals for a mean and proportion and perform one-sample z- and t-tests, correctly stating null and alternative hypotheses and interpreting p-values.	Worked-example lecture: instructor builds a confidence interval for a mean step by step (point estimate, standard error, critical value, margin of error) and interprets it; students then build one for a proportion using a provided poll dataset. Hypothesis testing lab: using a real dataset (e.g., city employee salary data), students state H0 and Ha, select z-test or t-test based on sample size and known/unknown population SD, compute the test statistic in Python with scipy.stats, and state a conclusion at α = 0.05. p-value misconception activity: students read three short paragraphs that misinterpret p-values (common published errors), identify the error in each, and write the correct interpretation; class debriefs together.	Jupyter Notebook, scipy.stats; city employee salary CSV (e.g., from a municipal open data portal); z-table and t-table handouts; p-value misconception article excerpts	Hypothesis testing lab graded on a 12-point rubric: correct H0/Ha (2 pts), correct test selection (2 pts), correct computation (4 pts), correct conclusion and plain-language interpretation (4 pts); pass mark 75%.
7	Two-Sample Tests and Chi-Square Analysis	12	lab	Students apply independent two-sample t-tests and chi-square tests of independence to answer business and policy questions from tabular data.	Two-sample t-test lab: students compare mean response times of two city departments using an open dataset; they check assumptions (normality, equal variance via Levene's test), run the test in scipy.stats, and interpret results in a short paragraph. Chi-square activity: given a contingency table of customer complaint types by region, students compute expected frequencies by hand, verify in Python, run chi_square contingency from scipy.stats, and state whether the variables are associated. Peer review: each student exchanges their written interpretation with a partner, checks for correct α-level reference, correct rejection decision, and plain-language conclusion; they give written feedback on one strength and one error.	Jupyter Notebook, scipy.stats (ttest_ind, levene, chi2_contingency); city department response-time CSV; contingency table handout; OpenIntro Statistics Chapter 6	Instructor evaluates completed notebooks; student must correctly run both test types and write accurate interpretations; pass mark 70% on a 10-point rubric.
8	Correlation and Simple Linear Regression	12	lab	Students compute Pearson correlation coefficients, fit a simple linear regression model, interpret coefficients and R-squared, and check residual assumptions.	Correlation lab: students compute Pearson r between five variable pairs in a housing dataset, produce a correlation matrix heat map with seaborn, and identify the pair with the strongest and weakest linear relationship. OLS regression lab: using statsmodels or scikit-learn, students fit a regression of house price on square footage, print the summary table, interpret the slope and intercept in context, and calculate a predicted value for a new observation. Residual diagnostics: students plot residuals vs. fitted values and a QQ-plot; they identify at least one assumption violation if present, describe it in writing, and suggest one remediation (log transform, removing outlier, etc.).	Jupyter Notebook, pandas, statsmodels, scikit-learn, seaborn; housing dataset (e.g., Ames Iowa housing data, public domain); OpenIntro Statistics Chapter 8	Notebook graded on 12-point rubric: correct correlation matrix (3 pts), correct regression output interpretation (5 pts), valid residual analysis (4 pts); pass mark 75%.
9	Multiple Regression, Statistical Pitfalls, and Communication	10	practice	Students build and interpret a multiple linear regression model, identify common statistical errors in published analyses, and present findings in plain language to a non-technical audience.	Multiple regression exercise: students add two additional predictors to their regression model from Lesson 8, check for multicollinearity using VIF, compare adjusted R-squared values, and write a model summary paragraph suitable for a manager. Statistical pitfalls case study: instructor presents four short case studies illustrating Simpson's paradox, p-hacking, survivorship bias, and confounding; students in groups diagnose the error and propose a corrected analysis approach. Presentation practice: each student prepares a three-minute verbal summary (no jargon) of their regression findings, including one chart; peers evaluate using a four-item rubric (clarity, accuracy, visual quality, actionability); instructor scores the final draft.	Jupyter Notebook, statsmodels (variance_inflation_factor), seaborn; housing dataset from Lesson 8; pitfalls case study handout; peer-review rubric	Instructor scores presentation and written model summary on a 10-point rubric: VIF check and correct multicollinearity interpretation (3 pts), correct adjusted R-squared comparison (3 pts), plain-language summary accuracy (4 pts); pass mark 70%.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Statistics Knowledge Exam	Written exam	25%	70% (35 of 50 items correct)	A 50-item written exam covering all nine lesson areas: data types, descriptive statistics, distributions, probability rules, CLT, confidence intervals, hypothesis testing (z, t, chi-square), correlation, and regression interpretation. Items include multiple-choice, short calculation, and one scenario-based interpretation question mapped to CompTIA Data+ Domain 2 (Data Analysis) and Google Data Analytics content areas. Standard met · Safety · Time · Quality/finish · Documentation
Regression Analysis Skills Demonstration	Skills demonstration	45%	75% on a 20-point rubric (15 of 20 points)	Each student receives a new dataset not used in lessons and must, within a 90-minute supervised session, clean it minimally, compute descriptive statistics, run a simple or multiple linear regression, produce residual plots, and deliver a five-minute oral interpretation to the instructor. The rubric assesses correct Python execution, valid assumption checking, accurate interpretation of coefficients and R-squared, and clarity of communication—skills mapped to IBM Data Science Professional and CompTIA Data+ exam objectives. Standard met · Safety · Time · Quality/finish · Documentation
Statistics Lab Log	Log	15%	Satisfactory rating (70% of rubric points) on at least 7 of 9 lesson lab entries	Students maintain a cumulative Jupyter Notebook lab log documenting their work, code, outputs, and written interpretations for each of the nine lessons. The instructor reviews the complete log at the end of the course, evaluating code correctness, chart labeling, written explanations, and evidence of error correction, ensuring students can demonstrate the iterative analytical process expected in professional data science roles. Standard met · Safety · Time · Quality/finish · Documentation
Workplace and Digital Safety Check	Safety audit	15%	100% on all mandatory safety items; no critical items may be missed	A structured checklist observation and a 10-item written quiz verifying that students follow safe ergonomic practices at computer workstations (OSHA General Industry ergonomics guidance), apply data privacy and cybersecurity hygiene (strong passwords, no sharing of credentials, locking screens), and can locate the emergency action plan and first-aid resources in the lab—consistent with OSHA 10 awareness covered in Course 1. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-03 Trade course

Python and R for Data Science & Analytics

103 hr · ~~$1,235~~ COMPLIMENTARY

Students develop practical programming proficiency in Python and R, the two primary languages used in data science workflows, covering syntax, data structures, file I/O, and analytical libraries. Instruction moves from core language mechanics through exploratory data analysis, statistical computing, and automation scripts that feed directly into later courses on cleaning, visualization, and machine learning. Lessons align with skill areas tested by the Google Data Analytics Certificate, IBM Data Science Professional Certificate, and CompTIA Data+ exam.

Outcomes

Write, debug, and document Python and R scripts that import, inspect, and summarize structured datasets using standard libraries.
Apply core data structures—lists, dictionaries, vectors, and data frames—to manipulate and transform real tabular data.
Use Python (pandas, NumPy) and R (tidyverse, dplyr) to perform exploratory data analysis and produce descriptive statistics.
Automate repetitive data tasks with loops, functions, and conditional logic in both languages.
Read and write common file formats (CSV, Excel, JSON) programmatically and handle common errors and exceptions.
Produce reproducible analytical notebooks (Jupyter, R Markdown) that combine code, output, and plain-language explanation.

Course text

How the course runs. 9 blocks: Environment Setup, Safety, and Programming Fundamentals; Python Syntax, Variables, and Core Data Structures; R Syntax, Vectors, and Data Frames; Control Flow, Functions, and Error Handling in Python; Data Import, Export, and File Formats; Exploratory Data Analysis with pandas and NumPy; Exploratory Data Analysis with the Tidyverse; Writing Reproducible Notebooks and Scripts; Integrated Python/R Mini-Project: End-to-End Analytical Script.

What competent looks like. Write, debug, and document Python and R scripts that import, inspect, and summarize structured datasets using standard libraries. Apply core data structures—lists, dictionaries, vectors, and data frames—to manipulate and transform real tabular data. Use Python (pandas, NumPy) and R (tidyverse, dplyr) to perform exploratory data analysis and produce descriptive statistics. Automate repetitive data tasks with loops, functions, and conditional logic in both languages. Read and write common file formats (CSV, Excel, JSON) programmatically and handle common errors and exceptions. Produce reproducible analytical notebooks (Jupyter, R Markdown) that combine code, output, and plain-language explanation.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Environment Setup, Safety, and Programming Fundamentals	10	lab	Students install and configure Python (Anaconda/Jupyter) and R (RStudio) on their workstations and demonstrate safe ergonomic and electrical practices at their data workstation.	Follow a step-by-step installation checklist to install Anaconda, Jupyter Notebook, R, and RStudio; verify each tool launches without error and record the version numbers in a lab log. Complete a workstation ergonomics self-audit using an OSHA-referenced checklist covering monitor height, seating posture, cable management, and surge-protector use; correct at least two findings and photograph before/after. Write and run a 'Hello, Data Science' script in both Python and R that prints the student's name, today's date, and a one-sentence description of a data analytics task; share to the class repository.	Student laptop or lab desktop, Anaconda installer (anaconda.com), RStudio installer (posit.co), OSHA Computer Workstation eTool reference sheet, institution GitHub or shared drive, lab log template	Installation checklist signed off by instructor with all tools running; ergonomics audit submitted with at least two corrective actions documented; both scripts execute without errors — pass requires all three items complete.
2	Python Syntax, Variables, and Core Data Structures	12	theory	Students write Python code that correctly uses variables, numeric and string types, lists, tuples, and dictionaries to store and retrieve data values.	Work through an annotated code walkthrough distinguishing int, float, str, bool, list, tuple, and dict; predict output before running each cell in Jupyter and record mismatches in the lab log. Complete 15 structured exercises (provided as a Jupyter notebook) that require creating, indexing, slicing, and updating lists and dictionaries representing small datasets (e.g., a list of city population values, a dictionary of sensor readings). Pair with a classmate to peer-review each other's solutions, identify at least one bug or style issue using PEP 8 guidelines, and push the corrected notebook to the shared repository with a descriptive commit message.	Jupyter Notebook, Python 3.x documentation (docs.python.org), PEP 8 style guide, exercise notebook provided by instructor, shared repository	Instructor reviews submitted notebook; 12 of 15 exercises must produce correct output and include a comment explaining the approach — maps to Google Data Analytics and CompTIA Data+ programming knowledge domains.
3	R Syntax, Vectors, and Data Frames	12	theory	Students write R scripts that create and manipulate vectors, factors, lists, and data frames to represent and access structured tabular data.	Follow a live-coded demo in RStudio to build a data frame from scratch using vectors of mixed types (numeric, character, logical, factor); add a new computed column and subset rows using bracket notation and the subset() function. Import a provided CSV file of state-level demographic data using read.csv(), inspect it with str(), head(), and summary(), and answer 10 written questions about the data structure (column types, row count, missing value flags). Rewrite the same data-frame operations using dplyr verbs (select, filter, mutate, arrange, summarize) and compare the output line by line with the base-R approach in a side-by-side R Markdown document.	RStudio, R documentation (r-project.org), tidyverse package (tidyverse.org), provided CSV dataset, R Markdown template, lab log	R Markdown document knits without errors; 8 of 10 inspection questions answered correctly; dplyr output matches base-R output for all operations — pass requires both conditions met.
4	Control Flow, Functions, and Error Handling in Python	12	demo	Students write Python functions that use conditionals, loops, and try/except blocks to automate a repeated data-processing task and handle at least two types of runtime errors.	Watch and narrate a step-by-step instructor demo that builds a function validating whether a numeric column value is within an acceptable range, raises a ValueError for out-of-range entries, and logs the bad record to a text file; students replicate the demo independently. Write a for-loop that reads five CSV files from a folder, calls the validation function on a specified column in each, and appends a summary row (filename, row count, error count) to a results data frame; run and debug until all five files process cleanly. Intentionally introduce three different errors (wrong file path, mismatched column name, non-numeric value) into copies of the CSV files and confirm that the try/except block catches each one with a descriptive printed message rather than crashing.	Jupyter Notebook, Python 3.x documentation, five provided CSV files (city traffic counts), instructor demo script, lab log	Function passes all three deliberately broken test cases with correct error messages and processes all five clean files without crashing; code includes docstring and inline comments — maps to IBM Data Science and CompTIA Data+ scripting domains.
5	Data Import, Export, and File Formats	11	lab	Students read and write CSV, Excel, and JSON files in both Python (pandas) and R (readr, jsonlite) and verify data integrity after each round-trip.	Use pandas read_csv(), read_excel(), and read_json() to load three versions of the same dataset; display shape, dtypes, and head() for each; document any differences caused by format conversion in the lab log. In R, use readr::read_csv() and jsonlite::fromJSON() to import the same files, then use write_csv() and toJSON() to export modified versions; open each exported file in a text editor to confirm formatting. Conduct a data-integrity check by re-importing each exported file, computing row counts and column checksums (sum of a numeric column), and asserting the values match the pre-export values using Python assert statements and R stopifnot().	Jupyter Notebook, RStudio, pandas library, readr package, jsonlite package, three provided datasets (CSV/Excel/JSON), lab log template	Lab log entries for all six import/export operations with matching checksums confirmed; assertion statements pass without error — pass requires zero failed assertions and complete log.
6	Exploratory Data Analysis with pandas and NumPy	12	practice	Students perform a structured exploratory data analysis on a real tabular dataset using pandas and NumPy, producing a summary report that describes shape, distributions, missingness, and outliers.	Load a publicly available dataset (e.g., a US city open-data file such as 311 service requests) into a pandas DataFrame; use describe(), value_counts(), isnull().sum(), and nunique() to build a written data dictionary with one paragraph per column. Use NumPy to compute mean, median, standard deviation, and the interquartile range for all numeric columns; flag any values more than three standard deviations from the mean as potential outliers and add a Boolean outlier column. Write a five-paragraph EDA narrative (in a Jupyter Markdown cell) that states the dataset's source, structure, key distributions, missing-data pattern, and two specific questions a stakeholder might answer with the data.	Jupyter Notebook, pandas documentation (pandas.pydata.org), NumPy documentation (numpy.org), publicly available open dataset, lab log	EDA notebook submitted with all code cells executed; data dictionary covers every column; outlier flagging logic is correct for at least one verified outlier; narrative addresses all five required points — maps to Google Data Analytics and IBM Data Science EDA competencies.
7	Exploratory Data Analysis with the Tidyverse	12	practice	Students use tidyverse packages (dplyr, tidyr, stringr) in R to group, aggregate, reshape, and summarize the same dataset used in the pandas lesson, and compare findings between the two language outputs.	Use dplyr group_by() and summarize() to calculate count, mean, and median for at least three categorical groupings; pipe the result into arrange(desc()) and export to CSV. Identify at least two columns with inconsistent formatting (e.g., mixed-case city names, extra whitespace) and use stringr functions str_to_lower(), str_trim(), and str_replace_all() to standardize them; document before/after counts in the lab log. Use tidyr pivot_longer() and pivot_wider() to reshape a wide summary table into long format and back; verify row and column counts match expectations and write a brief R Markdown explanation of when each shape is preferable.	RStudio, tidyverse documentation (tidyverse.org), stringr documentation, same open dataset from Lesson 6, R Markdown template, lab log	R Markdown document knits cleanly; group summaries match pandas output from Lesson 6 within rounding; string-cleaning documented with before/after counts; reshape round-trip row/column counts verified — pass requires all four checks.
8	Writing Reproducible Notebooks and Scripts	11	lab	Students produce a fully reproducible analytical notebook in Jupyter and an R Markdown report that a classmate can re-run from scratch on a fresh environment and obtain identical output.	Refactor a prior messy Jupyter notebook by moving repeated code into reusable functions, adding a requirements.txt file listing all package versions, and inserting Markdown headers and explanatory text between every major code section. Exchange notebooks with a partner who clones the repository, creates a new virtual environment using the requirements.txt, and attempts to run all cells top-to-bottom; the original author must resolve any environment or path errors the partner encounters. Write an R Markdown report covering the Lesson 7 tidyverse analysis; set a fixed random seed where applicable, use relative file paths, and knit to HTML; a second student knits the .Rmd file on their machine and confirms identical HTML output.	Jupyter Notebook, RStudio, Git/GitHub, requirements.txt convention, R Markdown documentation (rmarkdown.rstudio.com), lab log	Partner successfully re-runs Jupyter notebook with zero manual intervention after environment setup; R Markdown report knits identically on a second machine — maps to IBM Data Science reproducibility competencies; both conditions required to pass.
9	Integrated Python/R Mini-Project: End-to-End Analytical Script	11	lab	Students independently design, code, document, and present a short end-to-end analytical script in their choice of Python or R that answers a defined question from a provided real-world dataset.	Select one of three provided real-world datasets (public transit ridership, local weather records, or municipal budget allocations); write a one-paragraph problem statement specifying the analytical question, the intended audience, and the output format before any coding begins. Build the complete script or notebook: import data, clean at least two column-level issues, compute at least three summary statistics, and write the final summary table to a CSV and a formatted text report; include a function with a docstring for the main transformation step. Deliver a 5-minute live walkthrough to two classmates acting as stakeholder reviewers; respond to at least two clarifying questions; incorporate reviewer feedback into a final revision submitted to the course repository with a changelog comment.	Jupyter Notebook or RStudio (student choice), three provided datasets, Git/GitHub, lab log, peer-review rubric	Script runs end-to-end without manual edits on instructor machine; problem statement on file; at least one function with docstring present; summary table exported correctly; peer-review responses documented — maps to Google Data Analytics, IBM Data Science, and CompTIA Data+ applied-programming domains; all criteria required for pass.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Python and R Knowledge Exam	Written exam	25%	70% or higher (28 of 40 items correct)	A 40-item closed-book exam delivered in the LMS covering Python and R syntax, data structures, control flow, library functions (pandas, NumPy, tidyverse), file I/O, and reproducibility concepts. Items are drawn from the knowledge domains of the Google Data Analytics Certificate, CompTIA Data+, and IBM Data Science Professional Certificate and include multiple-choice, matching, and short-answer code-reading questions. Standard met · Safety · Time · Quality/finish · Documentation
Live Coding Skills Demonstration	Skills demonstration	45%	Pass on all four required tasks; partial credit not awarded	Students receive a previously unseen dataset and a written problem brief and have 60 minutes to write and run a script (Python or R, student's choice) that imports the data, resolves a specified cleaning issue, computes three requested statistics, and exports a summary CSV. The instructor evaluates correctness of output, presence of comments and a docstring, and whether the script runs without errors from top to bottom — aligning with IBM Data Science and CompTIA Data+ hands-on skill domains. Standard met · Safety · Time · Quality/finish · Documentation
Lab Log Portfolio	Log	15%	All 9 lesson lab log entries submitted; at least 7 rated Satisfactory or above on the rubric	Students maintain a running lab log throughout the course documenting setup steps, commands tried, errors encountered, corrections made, and brief reflections after each lesson's lab activity. The instructor reviews the complete portfolio at course end for completeness, accuracy of recorded commands, and evidence of troubleshooting; the log serves as a record of iterative learning consistent with professional data science practice. Standard met · Safety · Time · Quality/finish · Documentation
Workstation Safety and Ergonomics Check	Safety audit	15%	All six checklist items rated Compliant; any Deficient item must be corrected before the student may continue lab work	The instructor uses a standardized six-item checklist (cable management, surge protection, monitor height, seating posture, glare control, emergency-exit awareness) to inspect each student's workstation at mid-course and again at course end, consistent with OSHA computer workstation guidelines. This check verifies that students maintain the safe practices established in Lesson 1 and prepares them for worksite safety expectations during the externship. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-04 Trade course

SQL and PostgreSQL for Data Analytics

102 hr · ~~$1,225~~ COMPLIMENTARY

Students learn to design, query, and maintain relational databases using standard SQL and PostgreSQL, applying these skills to realistic data sets drawn from business, government, and civic contexts. The course covers data modeling, complex querying, performance tuning, and integration with Python and BI tools used across the program. Lessons map directly to Google Data Analytics, CompTIA Data+, and IBM Data Science Professional exam domains.

Outcomes

Write correct SQL queries—including multi-table JOINs, subqueries, window functions, and aggregations—against a PostgreSQL database to answer analytical questions.
Design a normalized relational schema from a plain-language data description and implement it in PostgreSQL with appropriate data types, primary keys, and foreign keys.
Import, export, and clean tabular data using SQL commands and PostgreSQL utilities, applying data-integrity constraints to prevent entry of invalid records.
Optimize slow queries by interpreting EXPLAIN/ANALYZE output and adding appropriate indexes.
Connect a PostgreSQL database to Python (psycopg2/SQLAlchemy) and to Power BI or Tableau, retrieving live query results for downstream analysis and visualization.
Apply safe ergonomic and cybersecurity practices in a database workstation environment and articulate data-privacy obligations when handling personally identifiable information.

Course text

How the course runs. 9 blocks: Relational Database Concepts and Workstation Safety; Installing PostgreSQL and Writing First Queries; Filtering, Aggregation, and Grouping; Joining Tables and Data Modeling; Subqueries, CTEs, and Window Functions; Data Import, Export, and Integrity Constraints; Query Optimization and Indexing; Connecting PostgreSQL to Python and BI Tools; Capstone Integration: Civic Data Analytics Project.

What competent looks like. Write correct SQL queries—including multi-table JOINs, subqueries, window functions, and aggregations—against a PostgreSQL database to answer analytical questions. Design a normalized relational schema from a plain-language data description and implement it in PostgreSQL with appropriate data types, primary keys, and foreign keys. Import, export, and clean tabular data using SQL commands and PostgreSQL utilities, applying data-integrity constraints to prevent entry of invalid records. Optimize slow queries by interpreting EXPLAIN/ANALYZE output and adding appropriate indexes. Connect a PostgreSQL database to Python (psycopg2/SQLAlchemy) and to Power BI or Tableau, retrieving live query results for downstream analysis and visualization. Apply safe ergonomic and cybersecurity practices in a database workstation environment and articulate data-privacy obligations when handling personally identifiable information.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Relational Database Concepts and Workstation Safety	9	theory	Students explain the relational model, identify the components of a PostgreSQL installation, and apply ergonomic and cybersecurity controls to a database workstation.	Instructor-led concept map: entities, attributes, relationships, primary keys, foreign keys, and normalization levels 1NF–3NF drawn on whiteboard; students reproduce the map in their own notes. Workstation safety walkthrough: students adjust chair height, monitor distance, and keyboard angle to OSHA ergonomic guidelines, then document their setup in a lab-log entry. Pair exercise: students identify three cybersecurity risks relevant to database work (weak passwords, unencrypted connections, unrestricted superuser access) and write one mitigation for each.	PostgreSQL 16 documentation (postgresql.org), OSHA ergonomics guidance for computer workstations, class VM image with PostgreSQL pre-installed, whiteboard/markers	Exit ticket: five short-answer questions on relational model vocabulary and two ergonomic controls; instructor marks for 80% correct before students proceed to Lesson 2.
2	Installing PostgreSQL and Writing First Queries	10	lab	Students install PostgreSQL, create a database, and execute correct SELECT, WHERE, ORDER BY, and LIMIT queries against a provided sample dataset.	Guided install: students install PostgreSQL on their workstation VM, initialize a cluster, and verify the service is running using psql and pgAdmin; instructor checks each machine before the class moves on. Data load: students use the psql \\copy command to load a 50,000-row CSV of public library checkout records into a pre-defined table, verifying row count with SELECT COUNT(*). Query sprint: students complete ten structured query challenges (e.g., 'List the ten most-checked-out titles in 2023') from a printed worksheet, saving each query in a .sql file.	PostgreSQL 16 installer, pgAdmin 4, sample library-checkouts CSV (public domain), query worksheet, student lab notebooks	Instructor reviews the ten .sql files; all ten queries must return the correct result set (verified against an answer key) for a pass—students with fewer than eight correct receive targeted re-instruction before the next lesson.
3	Filtering, Aggregation, and Grouping	11	practice	Students write queries using GROUP BY, HAVING, and aggregate functions (COUNT, SUM, AVG, MIN, MAX) to produce summary statistics from multi-row datasets.	Demonstration and guided notes: instructor live-codes progressively complex GROUP BY queries against the library dataset, narrating each clause; students follow along and annotate printed SQL syntax cards. Error-correction exercise: students receive five intentionally broken queries (wrong GROUP BY columns, HAVING vs. WHERE confusion) and must identify and fix each error in psql. Mini-project: students write a four-query analytical memo answering questions such as total checkouts by branch, average checkouts per patron, and branches whose monthly average exceeds a threshold, then share findings with a partner for peer review.	Library-checkouts PostgreSQL database from Lesson 2, SQL syntax reference cards (instructor-prepared), peer-review rubric	Partner peer review scored with rubric (query correctness, readability, and correct use of HAVING vs. WHERE); both partners must earn 80% to log the activity complete; instructor spot-checks three pairs.
4	Joining Tables and Data Modeling	12	lab	Students design a two-to-four table normalized schema from a business scenario and execute INNER, LEFT, RIGHT, and FULL OUTER JOIN queries correctly.	Schema design workshop: each student receives a written scenario (a small municipal permits office) and draws an entity-relationship diagram on paper, identifying tables, columns, and key relationships; instructor reviews diagrams before students write any SQL. DDL implementation: students translate their ER diagram into CREATE TABLE statements with correct data types and REFERENCES constraints, then insert 20 rows of sample data using INSERT statements. JOIN query set: students write eight queries across the permits schema that require at least one JOIN each, including at least one LEFT JOIN that surfaces permits with no associated contractor, saving results as CSV exports.	PostgreSQL 16 / pgAdmin 4, printed scenario handout, ER-diagram paper templates, draw.io (free tier) for digital ER diagrams, PostgreSQL documentation chapter on DDL	Instructor evaluates ER diagram for correct normalization (no repeating groups, all non-key columns depending on the primary key) and runs the eight JOIN queries against a reference database; 7 of 8 queries must return the correct result set to pass.
5	Subqueries, CTEs, and Window Functions	12	demo	Students rewrite nested subqueries as Common Table Expressions (CTEs) and apply window functions (ROW_NUMBER, RANK, LAG, LEAD, SUM OVER) to answer analytical questions that aggregate and detail simultaneously.	Instructor demonstration: live-code comparison of a correlated subquery versus an equivalent CTE against a sales transactions dataset; students identify which is more readable and explain why in a two-sentence written response. Window-function gallery walk: six printed 'station cards' are posted around the room, each showing a window-function use case; student pairs rotate through, run each query in psql, record the output, and write a plain-English interpretation. Challenge query: students independently write a CTE-plus-window-function query against the city permits schema that ranks contractors by total permit value within each permit category and flags the top performer in each category.	Sales transactions PostgreSQL dataset (instructor-provided), city permits schema from Lesson 4, station-card printouts, PostgreSQL window-function documentation	The challenge query is submitted as a .sql file; instructor runs it and checks that the ranking is correct and that the top-performer flag appears exactly once per category; pass requires a fully correct result with no runtime errors.
6	Data Import, Export, and Integrity Constraints	11	lab	Students load data from CSV and JSON sources into PostgreSQL using COPY and INSERT, enforce NOT NULL, UNIQUE, CHECK, and foreign-key constraints, and export query results in multiple formats.	Bulk load exercise: students use \\copy and the server-side COPY command to load three CSV files with different delimiters, date formats, and encoding issues; they document each error encountered and the SQL fix applied in their lab log. Constraint stress test: students add five constraints to an existing table, then attempt to insert intentionally invalid rows; they record which constraint blocked each bad row and explain what data quality problem each constraint prevents. Export pipeline: students export a filtered query result to CSV, then to a JSON array using PostgreSQL's json_agg function, and confirm the file can be opened in Python pandas with no import errors.	Three messy CSV files (instructor-prepared from public datasets), PostgreSQL COPY documentation, Python 3 with pandas installed, student lab notebooks	Lab log reviewed by instructor: must contain at least three documented import errors with correct fixes, all five constraint tests recorded with correct explanations, and evidence that both export files loaded successfully in pandas; 80% of checklist items complete to pass.
7	Query Optimization and Indexing	11	practice	Students interpret EXPLAIN ANALYZE output to identify sequential scans on large tables and add B-tree and partial indexes that measurably reduce query execution time.	Slow-query diagnosis: students run five pre-written slow queries against a 1-million-row public health dataset, capture EXPLAIN ANALYZE output, and annotate each plan identifying the costliest node. Index creation lab: students add appropriate indexes for each slow query, re-run EXPLAIN ANALYZE, and record before-and-after execution times in a comparison table in their lab notebook. Class discussion: pairs share one case where an index did not help (or caused a table-scan anyway due to low selectivity) and explain the reason; instructor synthesizes findings into a short whiteboard summary of index selection guidelines.	1-million-row public health CSV loaded into PostgreSQL (instructor-prepared from CDC open data), EXPLAIN ANALYZE cheat-sheet (instructor-prepared), lab notebook comparison table template	Comparison table must show measurable execution-time improvement for at least four of five queries, with correct identification of the plan node that changed; instructor verifies numbers are from actual query runs, not fabricated; pass requires four of five correct.
8	Connecting PostgreSQL to Python and BI Tools	14	lab	Students connect a PostgreSQL database to Python using psycopg2 and SQLAlchemy, and to Power BI using the PostgreSQL connector, retrieving live query results for analysis and visualization.	Python integration: students write a Python script that opens a psycopg2 connection, executes a parameterized query (using %s placeholders to prevent SQL injection), loads the result into a pandas DataFrame, and prints a five-row summary; instructor reviews the parameterization before the script is run. SQLAlchemy ORM mini-exercise: students use SQLAlchemy Core to reflect an existing table and run the same query used in the psycopg2 exercise, then compare the two connection approaches in a written paragraph. Power BI connection: students use the Get Data > PostgreSQL connector in Power BI Desktop to connect to the class database, import two tables, define a relationship in the model view, and build a two-visual report page; the report is saved and submitted as a .pbix file.	Python 3, psycopg2, SQLAlchemy, pandas (all via pip), Power BI Desktop (free), class PostgreSQL server credentials, SQL injection prevention reference (OWASP cheat sheet)	Instructor runs the Python script and confirms parameterized query executes without error and returns the correct row count; .pbix file is opened and both visuals must display correct data from live database queries; both components must pass for the lesson to be marked complete.
9	Capstone Integration: Civic Data Analytics Project	12	lab	Students apply all course skills—schema design, querying, optimization, and tool integration—to a realistic civic dataset, producing a documented SQL codebase and a short oral defense.	Project build: each student selects one dataset from a provided list of US open-data portals (e.g., city 311 service requests, county property assessments, transit ridership), designs and loads a normalized schema, and writes a minimum of twelve analytical queries ranging from simple aggregations to CTEs and window functions. Documentation sprint: students write a one-to-two page technical README covering schema decisions, key query explanations, one index added with before-and-after EXPLAIN ANALYZE evidence, and a brief data-privacy note identifying any PII present and how it was handled. Oral defense: each student presents their schema diagram and three queries to the instructor and one peer in a ten-minute session, answering questions about design choices and query logic.	US open-data portals (data.gov, local city data portals), PostgreSQL 16 / pgAdmin 4, Python or Power BI for at least one output visual, README template (instructor-provided), oral defense rubric	Oral defense rubric scored by instructor: schema correctness (normalized, keyed), query correctness (all twelve return expected results), documentation completeness, and ability to answer at least three follow-up questions; pass requires 80% of rubric points; any query returning incorrect results must be corrected before a pass is recorded.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
SQL Concepts and PostgreSQL Knowledge Exam	Written exam	25%	75% (38 of 50 points)	A 50-question written exam covering relational model theory, SQL clause syntax and semantics, PostgreSQL-specific features (CTEs, window functions, EXPLAIN ANALYZE, COPY), data types, constraint types, and index selection. Questions are multiple-choice and short-answer, mapped to Google Data Analytics (data aggregation and querying), CompTIA Data+ (database fundamentals), and IBM Data Science Professional (data collection and wrangling) exam domains. Standard met · Safety · Time · Quality/finish · Documentation
Timed Query Skills Demonstration	Skills demonstration	45%	6 of 8 queries return correct result sets within the 90-minute time limit	Students receive a fresh PostgreSQL database loaded with an unfamiliar public dataset and a printed brief of eight analytical questions; they write and execute SQL queries to answer each question without reference materials other than the official PostgreSQL documentation. The instructor verifies each result set against an answer key; this maps to CompTIA Data+ query writing and Google Data Analytics data extraction objectives. Standard met · Safety · Time · Quality/finish · Documentation
Lab Notebook and SQL Codebase Log	Log	15%	80% of checklist items present and correct	The instructor reviews each student's cumulative lab notebook (paper or digital) and their course .sql file repository against a 25-item checklist covering documented import errors and fixes, constraint tests, EXPLAIN ANALYZE before-and-after comparisons, Python connection script, Power BI .pbix file, and Capstone README; missing or inaccurate entries must be corrected and resubmitted within one week. Standard met · Safety · Time · Quality/finish · Documentation
Workstation and Data-Privacy Safety Check	Safety audit	15%	Pass/fail—all critical items must be marked satisfactory	Instructor observes each student at their workstation using a structured checklist covering ergonomic setup (monitor distance, chair height, keyboard angle per OSHA guidance), password hygiene (strong unique database password, no superuser credentials shared), encrypted connection use, and correct identification of any PII in their Capstone dataset with a documented mitigation; any critical item rated unsatisfactory requires immediate correction and re-check before the student may continue to Course 5. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-05 Trade course

Data Cleaning and Preparation for Analysis

102 hr · ~~$1,225~~ COMPLIMENTARY

Students develop systematic skills to identify, diagnose, and correct quality problems in real-world datasets using Python (pandas), R (tidyverse), and SQL before analysis or visualization. The course covers the full data-preparation pipeline—from profiling and auditing raw data through standardization, deduplication, outlier handling, and reproducible documentation of every transformation. Lessons map directly to Google Data Analytics Certificate task areas, CompTIA Data+ domain objectives on data quality and transformation, and IBM Data Science Professional Certificate data-wrangling modules.

Outcomes

Profile a raw dataset to quantify missing values, duplicate records, data-type errors, and distributional anomalies, producing a written quality audit report.
Apply at least four imputation strategies (mean/median/mode substitution, forward-fill, KNN imputation, and indicator variables) and justify the choice based on missingness mechanism (MCAR, MAR, MNAR).
Standardize strings, dates, units, and categorical codes across merged sources using Python pandas and R tidyverse, achieving zero format inconsistencies verified by automated tests.
Detect and resolve duplicate records and referential-integrity violations in a relational dataset using SQL and Python, documenting every decision in a reproducible cleaning script.
Identify outliers using IQR fences, z-scores, and visual inspection, then apply a defensible treatment (removal, capping, or flagging) consistent with the analysis goal.
Deliver a fully documented, version-controlled cleaning pipeline (Git repository with README, transformation log, and before/after summary statistics) that a peer can reproduce from raw data.

Course text

How the course runs. 9 blocks: Data Quality Fundamentals and the Cleaning Pipeline; Profiling and Auditing Raw Data; Handling Missing Data; Standardizing Strings, Dates, and Categorical Values; Deduplication and Referential Integrity; Outlier Detection and Treatment; Reproducible Cleaning Pipelines and Version Control; Cleaning Data in SQL and Integrating Sources; End-to-End Cleaning Project: Raw to Analysis-Ready.

What competent looks like. Profile a raw dataset to quantify missing values, duplicate records, data-type errors, and distributional anomalies, producing a written quality audit report. Apply at least four imputation strategies (mean/median/mode substitution, forward-fill, KNN imputation, and indicator variables) and justify the choice based on missingness mechanism (MCAR, MAR, MNAR). Standardize strings, dates, units, and categorical codes across merged sources using Python pandas and R tidyverse, achieving zero format inconsistencies verified by automated tests. Detect and resolve duplicate records and referential-integrity violations in a relational dataset using SQL and Python, documenting every decision in a reproducible cleaning script. Identify outliers using IQR fences, z-scores, and visual inspection, then apply a defensible treatment (removal, capping, or flagging) consistent with the analysis goal. Deliver a fully documented, version-controlled cleaning pipeline (Git repository with README, transformation log, and before/after summary statistics) that a peer can reproduce from raw data.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Data Quality Fundamentals and the Cleaning Pipeline	9	theory	Students will define the six dimensions of data quality (accuracy, completeness, consistency, timeliness, validity, uniqueness) and map each dimension to common real-world failure modes.	Read and annotate excerpts from the DAMA Data Management Body of Knowledge (DMBOK2) sections on data quality; students mark every term that matches a dimension and write a one-sentence definition in their own words. Examine three provided messy CSV files (a hospital visit log, a municipal permit table, and a retail transaction file); students complete a structured triage worksheet that lists at least two quality problems per dimension they can observe. Class discussion: students share triage findings, instructor builds a master issue list on the whiteboard, and the class collaboratively orders the cleaning steps into a repeatable pipeline diagram they photograph and keep for the course.	DAMA DMBOK2 (excerpts), three sample CSV files, structured triage worksheet, whiteboard, student laptops with Python 3 / Jupyter and R / RStudio installed	Students submit the completed triage worksheet; pass requires correctly classifying at least 10 of 14 seeded quality problems by dimension (71 % threshold).
2	Profiling and Auditing Raw Data	11	lab	Students will generate a comprehensive data-quality report for a provided dataset using pandas-profiling (ydata-profiling), R's skimr, and SQL COUNT/NULL queries, then summarize findings in a written audit memo.	Using a provided Jupyter notebook scaffold, students run ydata-profiling on a 50,000-row city inspection dataset, interpret every section of the HTML report (types, missing values, correlations, warnings), and annotate at least 15 specific findings. Replicate the profile in R using skimr and dplyr; students compare the two tool outputs side by side and note any discrepancies in column statistics, documenting the comparison in an R Markdown file. Write a two-page audit memo addressed to a fictional project manager that prioritizes the top five quality issues by severity, explains business impact in plain language, and recommends the next cleaning steps; peer-review using a provided rubric.	City inspection CSV (provided), Jupyter Lab, ydata-profiling library, RStudio, skimr and dplyr packages, audit memo template and peer-review rubric	Audit memo is graded with the peer-review rubric; pass requires a score of 75 % or higher across four criteria: completeness of findings, accuracy of statistics, clarity of impact statements, and actionable recommendations.
3	Handling Missing Data	11	lab	Students will diagnose the missingness mechanism (MCAR, MAR, or MNAR) for each variable in a dataset and apply the most appropriate imputation strategy, documenting the rationale in code comments.	Instructor-led demonstration (45 min): using a synthetic patient-records dataset, the instructor uses missingno visualizations and Little's MCAR test (via Python) to classify three variables as MCAR, MAR, and MNAR; students follow along and reproduce results in their own notebooks. Students independently apply four imputation methods—mean/median/mode substitution, pandas forward-fill, sklearn SimpleImputer, and binary missingness-indicator flags—to four assigned columns, then compare post-imputation distributions with before/after histograms and document which method preserves the original distribution best. Guided reflection: students write a half-page justification for each imputation choice; instructor reviews and returns written feedback within one class session.	Synthetic patient-records CSV, Jupyter Lab, missingno library, scikit-learn, matplotlib, seaborn, instructor-prepared demonstration notebook	Instructor reviews each notebook; pass requires correct mechanism classification for at least 3 of 4 variables and correctly applied code for all four imputation methods (no runtime errors, before/after plots present) — 75 % rubric score.
4	Standardizing Strings, Dates, and Categorical Values	11	lab	Students will clean and standardize free-text strings, date formats, and categorical codes from multiple sources into a single consistent schema using pandas string methods, regular expressions, and Python's datetime module.	Students receive a merged dataset combining three municipal data sources with inconsistent city-name spellings, mixed date formats (MM/DD/YYYY, YYYY-MM-DD, verbal), and categorical codes for neighborhood zone that differ by source; using a reference schema sheet, students write a pandas cleaning script that brings all three columns into conformance. Regular-expression workshop: instructor presents five common regex patterns for phone numbers, ZIP codes, email addresses, currency strings, and date fragments; students adapt and apply three of them to columns in their dataset, validating results with assert statements. Students run an automated test suite (provided pytest file with 12 assertions) against their cleaned DataFrame; they must achieve 12/12 passing tests before submitting the script.	Merged municipal CSV (3 sources), reference schema sheet, Jupyter Lab, pandas, re module, Python datetime, pytest, instructor-prepared test suite	Automated pytest suite must show 12/12 passing assertions (100 % required on automated tests); instructor spot-checks regex logic in code review — overall pass is 12/12 tests plus no hard-coded workarounds flagged in review.
5	Deduplication and Referential Integrity	11	lab	Students will identify and remove exact and near-duplicate records using pandas and fuzzy-matching (rapidfuzz), and resolve foreign-key violations in a relational dataset using SQL, producing a change log of every removed or corrected record.	Exact-duplicate lab: students use pandas drop_duplicates with different subset arguments on a business-license table; they record row counts before and after each pass and explain in comments why each subset choice is or is not appropriate for the business context. Fuzzy-matching exercise: using rapidfuzz, students match business names across two tables that represent the same entities but were entered by different staff; they set a similarity threshold, review borderline matches manually, and document accept/reject decisions in a CSV change log. SQL referential-integrity check: students run provided SQL queries against a PostgreSQL sandbox (orders and customers tables) to find orphaned foreign keys and NULL primary keys; they write UPDATE and DELETE statements to resolve the violations and verify with COUNT queries before and after.	Business-license CSV, PostgreSQL sandbox with orders/customers tables, Jupyter Lab, pandas, rapidfuzz library, DBeaver or psql client, change-log CSV template	Change log must be complete (every removed or corrected record listed with reason); SQL before/after counts must match expected values provided on an answer sheet; rubric pass at 75 % across completeness, correctness, and documentation criteria.
6	Outlier Detection and Treatment	11	lab	Students will detect numeric outliers using IQR fences, z-scores, and boxplot inspection, then apply a documented treatment (removal, Winsorization, or flagging) that is appropriate for the stated analysis goal.	Students compute IQR fences and z-scores for five numeric columns in a salary dataset; they produce side-by-side boxplots before and after treatment using seaborn and annotate each plot with the number of records affected. Case-comparison activity: instructor presents two analysis scenarios (calculating city-wide average salary vs. detecting wage fraud); students argue in writing why the same outlier should be treated differently depending on the goal—removal for the first, retention and flagging for the second. Students apply scipy.stats.mstats.winsorize to a column with extreme high values, then compare mean, median, and standard deviation before and after Winsorization in a summary table and write a one-paragraph interpretation.	Salary dataset CSV, Jupyter Lab, pandas, numpy, scipy, seaborn, matplotlib	Submitted notebook must include correct IQR/z-score calculations (verified against answer key), annotated plots for all five columns, and written case-comparison argument; pass at 75 % on a four-criteria rubric (calculation accuracy, plot quality, written justification, summary table).
7	Reproducible Cleaning Pipelines and Version Control	11	practice	Students will structure a multi-step cleaning workflow as a modular Python script with functions, a transformation log, and Git version control so that a peer can reproduce the cleaned output from raw data with a single command.	Refactoring workshop: students take a monolithic cleaning notebook from a previous lab and refactor it into a Python script with at least four named functions (load_raw, clean_strings, impute_missing, export_clean); instructor reviews function signatures and docstrings live. Transformation-log implementation: students add a Python logging configuration to their script that writes a timestamped entry for every transformation (e.g., '342 duplicate rows removed', '17 dates reformatted'); they run the script and inspect the log file. Git workflow exercise: students initialize a repository, make at least five commits with descriptive messages covering load, each cleaning step, and final export; write a README that explains how to run the pipeline; push to GitHub and swap repo URLs with a partner who clones and runs it, confirming the output matches.	Student laptops, Python 3, Git, GitHub accounts, prior lab dataset, VS Code or equivalent editor, logging module, provided script scaffold	Partner must successfully reproduce the cleaned output (SHA-256 hash of output CSV matches) with no manual intervention; README and commit history reviewed by instructor; pass requires successful reproduction plus five or more meaningful commits and a complete README.
8	Cleaning Data in SQL and Integrating Sources	11	lab	Students will write SQL queries that perform data-type casting, TRIM, COALESCE, CASE-WHEN recoding, and JOIN-based integration to prepare a multi-table dataset in PostgreSQL for analysis.	Students receive four un-normalized PostgreSQL tables representing a city's work-order system; they write SELECT queries using TRIM, LOWER, CAST, and COALESCE to standardize each table individually, then save results as views. Students write a multi-table JOIN that integrates the four views into a single analysis-ready table; they must handle NULLs from LEFT JOINs explicitly using COALESCE and add a CASE-WHEN column that recodes numeric priority codes into readable labels. Students run a final validation query that counts rows, checks for NULLs in required columns, and verifies referential consistency; they paste results into a validation checklist and submit both the SQL script and the completed checklist.	PostgreSQL sandbox, DBeaver or psql, work-order SQL dump file, validation checklist template	Validation checklist must show zero NULLs in required columns and row counts matching instructor answer key (±0 rows); SQL script reviewed for correct use of TRIM, COALESCE, CAST, CASE-WHEN, and JOIN; pass at 80 % on a correctness rubric.
9	End-to-End Cleaning Project: Raw to Analysis-Ready	16	practice	Students will independently execute the full cleaning pipeline—profile, impute, standardize, deduplicate, detect outliers, log transformations, version-control—on a new messy dataset and present a before/after quality report and reproducible code package.	Students receive a previously unseen 30,000-row dataset (city-provided open data with seeded and natural quality problems); over four in-class work sessions they apply all skills from lessons 1–8 with no scaffolded notebook, relying on their own prior scripts and documentation. Students prepare a before/after quality summary slide deck (maximum 10 slides) that shows key statistics (missing-value rates, duplicate counts, type error counts, outlier counts) before and after cleaning, with a narrative of every major decision. Students deliver a 10-minute live presentation of their pipeline and quality report to a panel of the instructor and one peer reviewer, answering at least two technical questions about their cleaning choices; the Git repository is submitted simultaneously.	New open-data CSV, student laptops with full Python/R/SQL environment, Git/GitHub, slide-presentation software, presentation rubric	Presentation rubric (technical accuracy, decision justification, communication clarity) scored by instructor and peer reviewer; reproducibility confirmed by instructor cloning and running the repository; pass requires 75 % on rubric AND successful reproduction of clean output.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Data Cleaning Concepts Knowledge Exam	Written exam	25%	70 % or higher (42/60 points)	A 60-question, closed-book exam covering data-quality dimensions, missingness mechanisms (MCAR/MAR/MNAR), imputation strategies, deduplication logic, outlier detection methods, SQL cleaning functions, and reproducibility best practices. Questions are mapped to Google Data Analytics Certificate data-cleaning task areas, CompTIA Data+ data quality and transformation domain objectives, and IBM Data Science Professional Certificate data-wrangling concepts; students receive a topic-alignment sheet so they can see exactly which exam domains each question tests. Standard met · Safety · Time · Quality/finish · Documentation
Timed Cleaning Skills Demonstration	Skills demonstration	45%	75 % on a 20-criterion rubric; automated test suite must pass at 100 %	Students are given a previously unseen messy CSV and 90 minutes to produce a cleaned DataFrame in a Jupyter notebook, including profiling output, imputation, string standardization, deduplication, outlier treatment, and a transformation log. The instructor runs a provided pytest suite against the submitted notebook output to verify correctness, then scores the code quality and documentation against a rubric aligned to Google Data Analytics and CompTIA Data+ performance objectives. Standard met · Safety · Time · Quality/finish · Documentation
Lab Notebook and Cleaning Portfolio Log	Log	15%	75 % average across all nine lesson lab logs	Students maintain a running lab notebook (digital, in a Git repository) that documents every lab exercise: the dataset used, quality problems found, methods applied, before/after statistics, and a brief reflection on what they would do differently. The instructor reviews the complete portfolio at the midpoint and end of the course, scoring each entry on accuracy, completeness, and quality of reflection using a four-point scale per entry. Standard met · Safety · Time · Quality/finish · Documentation
Workplace and Digital Safety Check	Safety audit	15%	100 % on all required safety behaviors; any fail item requires immediate remediation and recheck	The instructor observes each student against a 10-item behavioral checklist covering ergonomic workstation setup (monitor height, keyboard position, wrist posture per OSHA general industry ergonomics guidance), proper cable management to prevent trip hazards, correct response to an electrical-equipment malfunction (power off, report, do not re-energize), secure handling of sensitive data files (password-protected storage, no plain-text credentials in code repositories), and confirmation that the student has completed or has a current OSHA 10 card on file. All 10 items must be marked satisfactory; any unsatisfactory item halts lab access until corrected and rechecked. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-06 Trade course

Data Visualization: Principles, Tools, and Storytelling

102 hr · ~~$1,225~~ COMPLIMENTARY

Students learn to transform raw and cleaned datasets into accurate, accessible, and compelling visual communications using industry-standard tools including Tableau Public, Matplotlib, Seaborn, and ggplot2. The course emphasizes chart selection, design principles, accessibility standards, and honest representation of data—skills directly assessed in the Google Data Analytics Certificate, CompTIA Data+, and Microsoft PL-300 credential exams. Students complete progressively complex visualization projects culminating in a polished, audience-ready portfolio piece.

Outcomes

Select the correct chart type for a given data relationship (comparison, distribution, composition, or correlation) and justify the choice in writing.
Build publication-quality static visualizations in Python (Matplotlib and Seaborn) and R (ggplot2) that meet WCAG 2.1 color-contrast and accessibility guidelines.
Construct interactive visualizations in Tableau Public that include filters, tooltips, and calculated fields derived from a multi-table dataset.
Apply Gestalt design principles and pre-attentive attributes to reduce cognitive load and direct a viewer's attention to the intended insight.
Detect and correct misleading visualization practices—including truncated axes, dual-axis distortions, and cherry-picked time windows—in published charts.
Produce a complete data story with a narrative arc, annotated visuals, and an executive summary suitable for a non-technical audience.

Course text

How the course runs. 9 blocks: Why Visualization Matters: Perceptual Foundations and Chart Taxonomy; Design Principles: Gestalt, Pre-Attentive Attributes, and Accessibility; Static Visualization in Python: Matplotlib Fundamentals; Statistical Visualization in Python: Seaborn and Distribution Plots; Visualization in R: ggplot2 and the Grammar of Graphics; Misleading Visualizations: Detection, Analysis, and Ethical Correction; Interactive Visualization in Tableau Public: Core Features; Data Storytelling: Narrative Structure, Annotation, and Audience Adaptation; Capstone Visualization Project: End-to-End Build and Peer Defense.

What competent looks like. Select the correct chart type for a given data relationship (comparison, distribution, composition, or correlation) and justify the choice in writing. Build publication-quality static visualizations in Python (Matplotlib and Seaborn) and R (ggplot2) that meet WCAG 2.1 color-contrast and accessibility guidelines. Construct interactive visualizations in Tableau Public that include filters, tooltips, and calculated fields derived from a multi-table dataset. Apply Gestalt design principles and pre-attentive attributes to reduce cognitive load and direct a viewer's attention to the intended insight. Detect and correct misleading visualization practices—including truncated axes, dual-axis distortions, and cherry-picked time windows—in published charts. Produce a complete data story with a narrative arc, annotated visuals, and an executive summary suitable for a non-technical audience.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Why Visualization Matters: Perceptual Foundations and Chart Taxonomy	10	theory	Students will categorize at least 12 standard chart types by the data relationship each encodes and identify the perceptual channel (position, length, angle, color hue, etc.) each relies on.	Annotated chart gallery walk: students receive 20 printed or projected charts from published reports and label each with its chart type, data relationship, and primary perceptual channel on a structured worksheet. Lecture and guided note-taking on Edward Tufte's data-ink ratio, Cleveland and McGill's perceptual accuracy hierarchy, and the four families of data relationships (comparison, distribution, composition, correlation). Small-group debate: each group receives a dataset description and must argue for two competing chart choices, then present a one-minute rationale to the class.	Whiteboard, printed chart gallery handout, 'Storytelling with Data' by Cole Nussbaumer Knaflic (Ch. 1–2), 'The Visual Display of Quantitative Information' by Edward Tufte (selected pages), Google Data Analytics Certificate curriculum reference (Share Data Through the Art of Visualization module).	Exit ticket: a 10-question matching quiz pairing 10 scenario descriptions to the correct chart type and naming its perceptual channel. Pass = 8/10 correct.
2	Design Principles: Gestalt, Pre-Attentive Attributes, and Accessibility	10	theory	Students will redesign a cluttered, inaccessible chart by applying at least four Gestalt principles and verifying the result meets WCAG 2.1 AA color-contrast requirements using an online checker.	Instructor-led walkthrough of the six Gestalt principles (proximity, similarity, enclosure, closure, continuity, connection) applied to data charts, with before/after redesign examples on screen. Accessibility lab: students upload three sample charts to the WebAIM Contrast Checker and the Coblis color-blindness simulator, document failures, and propose corrected palettes. Individual redesign exercise: each student receives a deliberately over-designed bar chart and must produce a cleaner version in Google Slides or PowerPoint, annotating every change made and which principle it applies.	WebAIM Contrast Checker (webaim.org/resources/contrastchecker/), Coblis color-blindness simulator, 'Storytelling with Data' Ch. 3–4, WCAG 2.1 quick reference (W3C), sample cluttered charts handout, Google Slides or PowerPoint.	Redesigned chart submitted with a written annotation list. Instructor checks: contrast ratio passes AA standard for both normal and large text, at least four Gestalt edits identified correctly. Pass = all three criteria met.
3	Static Visualization in Python: Matplotlib Fundamentals	12	lab	Students will produce five distinct chart types (line, bar, histogram, scatter, box) in Matplotlib with proper titles, axis labels, and legend using a provided real-world dataset.	Instructor live-codes a fully labeled line chart in Jupyter Notebook, narrating every method call (figure size, color parameters, tick formatting, tight_layout); students code along on their own machines. Guided practice: students load the provided CSV (US city population data), complete a structured coding worksheet that asks them to build each of the five chart types using skeleton code with blanks to fill in. Peer review: students exchange notebooks, run each other's code, and complete a checklist verifying that every chart has a title, labeled axes with units, and a readable font size (minimum 10pt).	Jupyter Notebook, Python 3.x, Matplotlib library, provided US city population CSV, coding worksheet, 'Python for Data Analysis' by Wes McKinney (Matplotlib appendix), CompTIA Data+ study guide (visualization domain).	Submitted Jupyter Notebook with all five charts rendered and saved. Grader runs notebook top-to-bottom without errors and checks checklist criteria. Pass = all five charts render without error and all checklist items met.
4	Statistical Visualization in Python: Seaborn and Distribution Plots	11	lab	Students will build and interpret distribution, categorical, and relational Seaborn plots—including KDE, violin, pair plot, and heatmap—and correctly describe the statistical story each chart reveals in written captions.	Instructor demonstration of Seaborn's figure-level vs. axes-level API distinction, with annotated live-coding of a pair plot and correlation heatmap on the Gapminder dataset. Independent lab: students load a provided health-indicator dataset and complete a lab card requiring one KDE plot, one violin plot grouped by a categorical variable, one scatter plot with a regression line (lmplot), and one annotated heatmap—each with a two-sentence caption. Class critique session: six student charts are projected anonymously; the group identifies one strength and one improvement for each, instructor records feedback on the board and connects comments to design principles from Lesson 2.	Jupyter Notebook, Python 3.x, Seaborn library, Gapminder dataset (gapminder.org/data/), provided health-indicator CSV, Seaborn official documentation (seaborn.pydata.org), lab card handout.	Submitted notebook with four required charts and captions. Instructor scores captions for statistical accuracy (does the caption correctly name the distribution shape or correlation direction?). Pass = all four charts render, all four captions are statistically accurate.
5	Visualization in R: ggplot2 and the Grammar of Graphics	11	lab	Students will construct a layered ggplot2 visualization in R using geom, aesthetic mapping, faceting, and a custom theme, and export it as a 300 dpi PNG file.	Lecture on Hadley Wickham's Grammar of Graphics framework: data, aesthetics, geometries, statistics, coordinates, and themes—students complete a concept map that maps each layer to a concrete ggplot2 function. Guided coding exercise in RStudio: students build a faceted scatter plot of the built-in 'mpg' dataset step-by-step, adding layers one at a time (geom_point → color aesthetic → facet_wrap → theme_minimal → labs), running the plot after each addition to see incremental changes. Independent challenge: students reproduce a target chart (provided as a PNG image) using a new dataset (provided CSV), matching axis labels, facets, and color scheme as closely as possible, then export the result using ggsave() at 300 dpi.	RStudio, R 4.x, ggplot2 package (part of tidyverse), provided CSV dataset, target chart PNG handout, 'R for Data Science' by Hadley Wickham (Ch. 3 and 28, freely available at r4ds.had.co.nz).	Submitted .R script and exported PNG. Instructor checks: plot renders from script without error, faceting is present, custom theme applied, file is 300 dpi. Pass = all four criteria met.
6	Misleading Visualizations: Detection, Analysis, and Ethical Correction	8	theory	Students will identify at least five distinct misleading visualization techniques in a curated set of published charts and produce a corrected version of two charts with a written explanation of each deception.	Instructor-led case study analysis of five real published charts that use truncated y-axes, dual-axis distortion, area vs. linear scaling errors, cherry-picked date ranges, or misleading pie charts—students complete an error-identification form for each. Small-group 'chart autopsy': each group receives one deceptive chart from a news or government source, identifies the technique used, and presents a one-paragraph written indictment to the class explaining what the chart implies vs. what the data actually show. Individual correction task: students select two charts from the case study set and produce corrected versions (in any tool used so far) with a 150-word written explanation per chart describing the original deception and how the correction addresses it.	Printed or projected set of 10 real deceptive charts (sourced from media and published reports), error-identification form handout, 'How Charts Lie' by Alberto Cairo (selected chapters), CompTIA Data+ exam objective list (data integrity and ethics sections).	Submitted corrected charts and written explanations. Instructor checks: deception technique correctly named, correction addresses the specific distortion, explanation is factually accurate. Pass = both corrections accepted (2/2 must pass; a second attempt is allowed within one week).
7	Interactive Visualization in Tableau Public: Core Features	14	demo	Students will build an interactive Tableau Public workbook containing three connected worksheets—a bar chart, a map, and a time-series line—with working dimension filters and tooltips using a provided multi-table dataset.	Instructor screen-share demonstration of connecting Tableau to a CSV and to a Postgres database (via live connection), creating a relationship between two tables, and building a basic bar chart with color encoding—students observe first, then replicate steps immediately after. Guided practice using the provided dataset (US county-level economic indicators): students follow a step-by-step lab card to build the bar chart, geographic map, and time-series line, add a global dimension filter, and customize tooltips to show three fields. Publishing and sharing exercise: students publish the finished workbook to Tableau Public, copy the embed link, and submit it along with a one-page design rationale explaining their color choice and what insight each worksheet is intended to communicate.	Tableau Public (free desktop app), provided US county economic indicators dataset (multi-table CSV or Postgres connection), Tableau Public account, lab card handout, Tableau official training videos (public.tableau.com/learn/training), Microsoft PL-300 study guide (for comparison of BI tool concepts).	Submitted Tableau Public link and design rationale. Instructor opens link and verifies: all three chart types present, global filter works, tooltips display three fields, workbook is publicly accessible. Pass = all four functional criteria met and rationale submitted.
8	Data Storytelling: Narrative Structure, Annotation, and Audience Adaptation	12	practice	Students will construct a five-slide visual story for a specified audience (executive, technical, or public) that includes a situation-complication-resolution narrative arc, annotated charts, and a written executive summary.	Lecture and worksheet on the Situation-Complication-Resolution (SCR) story framework applied to data presentations, with three contrasting examples showing how the same dataset is framed differently for an executive, a data engineer, and a general public audience. Annotation workshop: students take two of their own previously completed charts and add direct data labels, callout annotations pointing to the key finding, and a one-sentence 'so what' title—instructor circulates and gives real-time feedback. Full story build: each student selects a dataset from a provided list (or their own cleaned dataset from Course 5), identifies an audience, and produces a five-slide deck using Google Slides or PowerPoint with at least three annotated charts, a narrative arc, and a 200-word executive summary on slide one.	'Storytelling with Data' by Cole Nussbaumer Knaflic (Ch. 6–9), provided dataset list, Google Slides or PowerPoint, annotation guide handout, Google Data Analytics Certificate curriculum reference (storytelling and presentation modules).	Submitted five-slide deck and executive summary. Instructor uses a rubric scoring narrative arc (present/absent), annotation quality (callouts point to findings, not just labels), audience appropriateness, and chart accuracy. Pass = 70% or higher on rubric (each of four rubric criteria scored 0–25).
9	Capstone Visualization Project: End-to-End Build and Peer Defense	14	practice	Students will independently produce a complete visualization portfolio piece—including Python or R static charts, a Tableau Public interactive dashboard, and a data story deck—for a real dataset, then defend their design decisions in a 10-minute peer critique session.	Project work sessions (two class periods): students work independently to build all deliverables; instructor and any available lab assistant circulate to unblock technical issues, review design drafts, and prompt students to articulate their choices verbally before the defense. Written documentation: students produce a one-to-two page design journal documenting their dataset source, data cleaning steps taken, chart type rationale for each visual, accessibility decisions made, and any misleading patterns they intentionally avoided. Peer defense panel: groups of four students take turns presenting their Tableau dashboard and one static chart for 10 minutes each, followed by five minutes of structured peer questions using a provided critique card; instructor observes and scores each presenter independently.	All tools used in the course (Jupyter Notebook, RStudio, Tableau Public), student's own dataset selected and cleaned in earlier lessons, design journal template, critique card handout, course-wide rubric (covers technical accuracy, design principles, accessibility, and storytelling).	All deliverables submitted (static charts file, Tableau Public link, data story deck, design journal) and defense completed. Scored on four-criterion rubric (technical accuracy, design principles, accessibility, storytelling), each 0–25. Pass = 70/100 overall with no criterion below 15/25.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Visualization Principles Knowledge Exam	Written exam	25%	75% or higher (30 of 40 questions correct)	A 40-question closed-book exam covering chart taxonomy, perceptual channels, Gestalt principles, WCAG 2.1 accessibility requirements, misleading visualization techniques, and the grammar of graphics. Items are formatted as multiple choice and matching to mirror the style used in the CompTIA Data+ and Google Data Analytics Certificate exams. Standard met · Safety · Time · Quality/finish · Documentation
Tableau Public Interactive Dashboard Skills Demo	Skills demonstration	45%	All five functional criteria met and rubric score of 70/100 or higher	Students are given a new, previously unseen dataset and 90 minutes to build a three-worksheet Tableau Public workbook with a working filter, custom tooltips, a geographic map, and a calculated field, then publish it and submit the link with a five-minute verbal walkthrough recorded or delivered live. Scored on a rubric covering functionality, design, accuracy, and communication; maps directly to PL-300 (Power BI) data visualization competency areas. Standard met · Safety · Time · Quality/finish · Documentation
Visualization Lab Log	Log	15%	8 of 9 lessons documented with all required entries present and no unresolved errors	Students maintain a running lab log throughout the course in a provided digital template, recording for each lesson: the dataset used, tools and libraries invoked, design decisions made and their rationale, errors encountered and how they were resolved, and the chart type produced. The log is collected at course end and reviewed for completeness, accuracy, and evidence of iterative problem-solving. Standard met · Safety · Time · Quality/finish · Documentation
Workplace and Digital Safety Check	Safety audit	15%	Pass/Fail — all six items must be demonstrated correctly; a single failure requires a full re-check	Instructor observes each student in the lab setting and checks six criteria: workstation ergonomic setup (monitor height, wrist position, seating), correct procedure for reporting a data breach or accidental publication of PII discovered in a dataset, proper file-naming and version-control habits to prevent overwriting clean data, verification that published Tableau Public workbooks contain no personally identifiable information, shutdown and logout procedure followed at session end, and demonstrated knowledge of where to report a safety concern in the workplace. Connects to the OSHA General Industry standards for office environments and the data-ethics safety practices introduced in Course 1 and reinforced throughout the program. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-07 Trade course

Dashboards: Design, Build, and Deploy with Power BI and Tableau

102 hr · ~~$1,225~~ COMPLIMENTARY

Students design, build, and publish interactive dashboards using Microsoft Power BI and Tableau Public, applying data modeling, DAX measures, and UX best practices to real datasets. The course maps directly to the Microsoft PL-300 exam domain covering reports and dashboards, and reinforces Google Data Analytics and CompTIA Data+ competencies in data visualization and storytelling. Learners finish with a portfolio-ready published dashboard defended before an industry panel.

Outcomes

Connect, shape, and model data from at least two source types in Power BI Desktop and Tableau, producing a clean star-schema data model.
Write DAX calculated columns and measures to support KPI cards, time-intelligence comparisons, and dynamic filtering in Power BI.
Apply data visualization best practices—including appropriate chart selection, color accessibility (WCAG contrast), and decluttered layouts—to produce dashboards readable by a non-technical audience.
Publish and configure a live Power BI report to the Power BI Service, set a scheduled data refresh, and manage row-level security for at least two user roles.
Build a Tableau Public dashboard with at least one calculated field, one parameter control, and one story point narrative, and share it via a public URL.
Document design decisions, data lineage, and refresh schedules in a dashboard technical spec and defend the product before peers and an evaluator.

Course text

How the course runs. 9 blocks: Dashboard Fundamentals: Purpose, Anatomy, and Tool Landscape; Connecting and Shaping Data in Power BI Desktop; Data Modeling: Star Schemas and Relationships in Power BI; DAX: Calculated Columns, Measures, and Time Intelligence; Report Design: Charts, Filters, and UX Accessibility; Publishing, Sharing, and Row-Level Security in Power BI Service; Tableau Public: Calculations, Parameters, and Stories; Advanced Dashboard Patterns: Drill-Through, Bookmarks, and Mobile Layout; Capstone Dashboard Build and Defense.

What competent looks like. Connect, shape, and model data from at least two source types in Power BI Desktop and Tableau, producing a clean star-schema data model. Write DAX calculated columns and measures to support KPI cards, time-intelligence comparisons, and dynamic filtering in Power BI. Apply data visualization best practices—including appropriate chart selection, color accessibility (WCAG contrast), and decluttered layouts—to produce dashboards readable by a non-technical audience. Publish and configure a live Power BI report to the Power BI Service, set a scheduled data refresh, and manage row-level security for at least two user roles. Build a Tableau Public dashboard with at least one calculated field, one parameter control, and one story point narrative, and share it via a public URL. Document design decisions, data lineage, and refresh schedules in a dashboard technical spec and defend the product before peers and an evaluator.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Dashboard Fundamentals: Purpose, Anatomy, and Tool Landscape	9	theory	Students distinguish operational, analytical, and strategic dashboards and match each to appropriate tools and design patterns.	Annotated critique exercise: students receive printed screenshots of five real-world dashboards (Power BI, Tableau, Looker, Google Data Studio) and label chart types, KPI tiles, filters, and navigation elements, then score each against a provided rubric. Tool-comparison matrix: working in pairs, students research and complete a feature/cost/licensing comparison table for Power BI, Tableau, Google Looker Studio, and Tableau Public, noting which features map to PL-300 exam objectives. Concept map: each student draws a concept map connecting the terms data source, model, report, dashboard, and story, then explains their map to a partner in a two-minute verbal summary.	Whiteboard, printed dashboard screenshots (instructor-prepared packet), Microsoft PL-300 Study Guide (Microsoft Press), CompTIA Data+ Study Guide (Wiley), internet access for tool research	Students score at least 80% on a 10-question exit quiz identifying dashboard type, appropriate chart, and tool match for given business scenarios.
2	Connecting and Shaping Data in Power BI Desktop	12	lab	Students import data from a CSV file, an Excel workbook, and a SQL Server or PostgreSQL database into Power BI Desktop and apply Power Query transformations to produce a clean, typed table.	Guided lab: connect to a provided CSV of city permit data and a PostgreSQL database of budget records; use Power Query Editor to remove duplicate rows, promote headers, change data types, and merge queries into one fact table. Error-hunting exercise: instructor distributes a deliberately broken .pbix file with four Power Query errors (null type mismatch, broken file path, wrong delimiter, date format error); students identify and fix each error and document the fix in a lab log. M-formula exploration: students modify one automatically generated M step by hand in the Advanced Editor to filter rows where a numeric column exceeds a threshold, then verify the result row count matches an expected value.	Power BI Desktop (free, current version), provided CSV and Excel sample datasets, access to class PostgreSQL instance (from Course 4), Microsoft Power Query documentation (docs.microsoft.com), lab log template	Instructor reviews each student's .pbix file; pass requires correct data types on all columns, zero errors in Power Query pane, and a merged table matching the instructor's answer key row count (±0 rows). PL-300 mapping: Prepare the data domain.
3	Data Modeling: Star Schemas and Relationships in Power BI	10	demo	Students construct a star-schema data model with at least one fact table and two dimension tables, define correct relationship cardinality and cross-filter direction, and explain why fan-out and many-to-many relationships cause incorrect aggregations.	Live instructor demo followed by immediate replication: instructor builds a star schema from three tables on the projector; students replicate every step simultaneously and call out discrepancies. Cardinality diagnosis: students receive a pre-built model with two incorrect relationship settings (many-to-many and wrong cross-filter direction); they diagnose the symptom (wrong totals in a sample visual), correct the relationships, and record before/after screenshots in their lab log. Schema documentation: students draft an entity-relationship diagram of their model using draw.io or Lucidchart, labeling primary keys, foreign keys, cardinality symbols, and filter direction arrows.	Power BI Desktop, provided .pbix starter file, draw.io or Lucidchart (free tier), Microsoft documentation on model relationships, lab log	ER diagram reviewed by instructor; pass requires correct cardinality on all relationships, no active many-to-many relationships without a bridge table, and a written one-sentence justification for each cross-filter direction. PL-300 mapping: Model the data domain.
4	DAX: Calculated Columns, Measures, and Time Intelligence	14	lab	Students write DAX measures using CALCULATE, FILTER, and time-intelligence functions (TOTALYTD, SAMEPERIODLASTYEAR) and correctly distinguish when to use a calculated column versus a measure.	Scaffolded DAX worksheet: students complete a progression of 12 DAX tasks printed on a worksheet—starting with SUM and COUNTROWS, advancing to CALCULATE with a filter argument, and ending with a year-over-year variance measure—testing each in a card visual. Error-message decoding: instructor shows four common DAX errors (circular dependency, blank measure, wrong context transition, missing relationship) via screenshots; students match each error to its cause and write the corrected DAX. KPI measure build: each student creates three business KPIs of their choice from the class dataset (e.g., total revenue YTD, % change vs. prior year, running total) and formats them as card visuals on a blank report page, with units and thousands separator.	Power BI Desktop, DAX Guide reference (dax.guide), provided .pbix dataset, DAX task worksheet (instructor-prepared), lab log	Instructor runs a provided check query against each student's model; all 12 DAX measures must return values within 0.1% of the answer key. Three KPI measures must render without error and display correct data. PL-300 mapping: Model the data domain; Visualize and analyze the data domain.
5	Report Design: Charts, Filters, and UX Accessibility	12	practice	Students build a two-page Power BI report applying chart-selection principles, consistent color palette, WCAG AA contrast ratios, and slicer/cross-filter interactions that a non-technical manager can navigate without instruction.	Chart-selection drill: students receive 10 business questions (e.g., 'show sales trend over 24 months,' 'compare five product categories by revenue'); they choose the correct chart type for each, justify the choice in writing, and build the visual in Power BI. Accessibility audit: using the Power BI built-in accessibility checker and the WebAIM Contrast Checker tool, students audit a peer's report page, log every contrast or alt-text failure, and hand the log back for the peer to fix. Usability walk-through: a classmate unfamiliar with the dataset uses only the report (no verbal explanation) to answer five pre-written business questions; the builder records which questions the tester could and could not answer and revises the layout accordingly.	Power BI Desktop, WebAIM Contrast Checker (webaim.org/resources/contrastchecker), Power BI accessibility documentation, Stephen Few 'Show Me the Numbers' (reference text), usability question cards (instructor-prepared)	Report passes Power BI accessibility checker with zero errors; all five usability questions answered correctly by the test user without verbal help; instructor spot-checks three chart choices against the chart-selection rubric with 80% or better score. PL-300 mapping: Visualize and analyze the data domain.
6	Publishing, Sharing, and Row-Level Security in Power BI Service	12	lab	Students publish a Power BI report to a Power BI Service workspace, configure a scheduled data refresh, share the report with a guest user, and implement row-level security (RLS) restricting two user roles to distinct data subsets.	Publish and schedule lab: students publish their report from Power BI Desktop to the class workspace, configure a daily scheduled refresh against the class PostgreSQL gateway, and screenshot the refresh history after a manual trigger. RLS configuration: students create two DAX-based RLS roles (e.g., 'Region_East' and 'Region_West') in Power BI Desktop, publish, assign each role to a test email address in the Service, and use the 'View as role' feature to verify each role sees only the correct rows. Sharing and permissions review: students share the published report with a partner's Microsoft 365 account at 'view only' permission, have the partner open it and confirm they cannot edit, then revoke access and confirm the partner can no longer open the link.	Power BI Service (free or Pro trial account), Microsoft 365 test accounts (instructor-provisioned), class PostgreSQL instance with on-premises data gateway or import-mode dataset, Power BI Service documentation	Instructor verifies scheduled refresh shows 'Succeeded' in refresh history; both RLS roles return correct filtered row counts verified against SQL query answer key; partner confirms share/revoke cycle worked. PL-300 mapping: Deploy and maintain assets domain.
7	Tableau Public: Calculations, Parameters, and Stories	14	lab	Students build a Tableau Public workbook containing at least three coordinated views, one parameter control, one calculated field, and a two-slide story, then publish it to a personal Tableau Public profile.	Guided Tableau build: using a provided city open-data CSV, students connect the data, build a bar chart, a line trend, and a filled map, and arrange all three on a single dashboard with a filter action linking the map to the bar chart. Parameter and calculated field lab: students create a numeric parameter (e.g., 'Top N selector') and a calculated field using an IF/THEN or CASE expression; they embed the parameter in a title so the chart headline updates dynamically when the user moves the slider. Story point narrative: students add a two-slide story—slide 1 shows the default state with an annotation explaining the key insight; slide 2 highlights an outlier using a highlight filter and a callout text box—then publish to Tableau Public and submit the URL.	Tableau Public Desktop (free download), provided city open-data CSV, Tableau Public profile (free account), Tableau online help (help.tableau.com), lab log	Instructor visits each student's published Tableau Public URL; pass requires working dashboard filter action, parameter that dynamically updates at least one view title, calculated field returning correct values verified against a spot-check formula, and two story slides with annotations. Google Data Analytics mapping: Create visualizations and communicate findings.
8	Advanced Dashboard Patterns: Drill-Through, Bookmarks, and Mobile Layout	10	demo	Students implement drill-through pages, bookmark-based navigation buttons, and a mobile-optimized layout in Power BI so the dashboard functions correctly on both desktop and a phone screen.	Drill-through setup: instructor demos drill-through in Power BI; students immediately replicate by creating a detail page that activates when a user right-clicks a data point on the summary page and transfers the filter context to the detail page. Bookmark navigator: students create three bookmarks representing different filter states, then add three button shapes linked to those bookmarks to simulate tab navigation without using the standard slicer panel, and test that each button resets correctly. Mobile layout workshop: students open the mobile layout editor, rearrange visuals for a portrait phone canvas (320×568 pt reference), preview in the phone emulator, and submit a screenshot of the mobile view alongside the desktop view showing intentional differences.	Power BI Desktop, Power BI mobile emulator (built into Desktop), Microsoft documentation on bookmarks and drill-through, lab log	Instructor tests drill-through on at least two data points and confirms correct filter transfer; bookmark buttons cycle through all three states without error; mobile layout screenshot shows at least three visuals repositioned compared to desktop. PL-300 mapping: Visualize and analyze the data domain.
9	Capstone Dashboard Build and Defense	9	practice	Students independently design, build, document, and present a complete multi-source dashboard product—using either Power BI or Tableau—that answers a defined set of business questions, supported by a written technical specification.	Independent build session: using a dataset not used in earlier labs (instructor-approved city or open-government dataset), each student completes their dashboard entirely in class without instructor assistance, referencing only published documentation and their own notes. Technical specification document: each student completes a two-page technical spec template covering data sources, transformation steps, data model diagram, list of all measures or calculated fields with formulas, refresh schedule, and RLS or permissions plan. Five-minute panel defense: each student presents the live dashboard to a two-person panel (instructor plus one peer evaluator), answers three questions drawn at random from a question bank covering design choices, DAX or calculated-field logic, and refresh configuration.	Power BI Desktop or Tableau Public, instructor-approved open-government dataset, technical spec template (instructor-provided), panel question bank (instructor-prepared), rubric	Rubric scored by instructor and peer evaluator independently; pass requires 80% or above on five criteria: data model correctness, measure/formula accuracy, visual appropriateness, accessibility compliance, and defense question responses. Scores averaged; any criterion below 60% requires targeted remediation and resubmission. Maps to PL-300 all domains, Google Data Analytics, and CompTIA Data+.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Dashboard Concepts and Tools Knowledge Exam	Written exam	25%	75% correct (30 of 40 questions)	A 40-question multiple-choice and matching exam covering dashboard taxonomy, Power BI data-model concepts, DAX syntax rules, Tableau calculated-field logic, chart-selection principles, RLS configuration, and PL-300 exam-mapped terminology. Questions are drawn from all theory and demo lessons and aligned to PL-300 domain weightings and CompTIA Data+ visualization objectives. Standard met · Safety · Time · Quality/finish · Documentation
Live Dashboard Skills Demonstration	Skills demonstration	45%	Score of 80% or higher on a 20-point rubric; no criterion scored zero	Each student is given a new two-table dataset and 90 minutes to build and publish a Power BI report with at least one DAX measure, one slicer, one drill-through page, and correct RLS for two roles; the instructor evaluates data model accuracy, measure correctness, visual design, and publish/share configuration against the rubric in real time. Standard met · Safety · Time · Quality/finish · Documentation
Lab Log Portfolio	Log	15%	All 6 required lab entries submitted and each entry rated 'complete' by instructor (all required fields present, screenshots legible, errors documented with resolution)	Students maintain a running lab log throughout the course capturing screenshots, error messages and fixes, DAX or M formulas used, and brief written reflections for six designated lab sessions (Lessons 2, 3, 4, 6, 7, and 8); the portfolio is reviewed at the end of the course to confirm consistent documentation habits required in professional analytics environments. Standard met · Safety · Time · Quality/finish · Documentation
Ergonomics and Digital-Workspace Safety Check	Safety audit	15%	Pass/Fail: all six checklist items marked 'met'; any 'not met' item requires correction before the student may continue unsupervised lab work	Instructor conducts a workstation walkthrough using a six-item safety checklist aligned to OSHA general industry ergonomics guidance and the program's Universal Core safety content, verifying correct monitor height and distance, adequate lighting without screen glare, cable management preventing trip hazards, correct posture and chair adjustment, functioning surge protector or UPS, and knowledge of the building's emergency exit route from the lab. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-08 Trade course

Introduction to Machine Learning for Data Analytics

102 hr · ~~$1,225~~ COMPLIMENTARY

Students build foundational machine learning literacy by implementing supervised and unsupervised algorithms in Python using scikit-learn, evaluating model performance with industry-standard metrics, and communicating results to non-technical stakeholders. The course bridges earlier Python, statistics, and data-cleaning skills to real predictive analytics workflows aligned with CompTIA Data+, IBM Data Science Professional, and Google Data Analytics credential exam domains. Safety, ethical handling of training data, and reproducible documentation practices are integrated throughout.

Outcomes

Explain the difference between supervised, unsupervised, and reinforcement learning and select an appropriate algorithm family for a given business problem.
Prepare a labeled dataset through train/validation/test splitting and basic feature engineering using pandas and scikit-learn pipelines.
Train, tune, and evaluate classification and regression models using cross-validation, confusion matrices, ROC-AUC, RMSE, and R² metrics.
Apply at least one unsupervised clustering algorithm (k-means) and interpret cluster assignments in a business context.
Identify and mitigate common ML failure modes including data leakage, overfitting, and class imbalance.
Produce a reproducible ML project notebook with documented methodology, model card, and a plain-language summary suitable for a professional portfolio.

Course text

How the course runs. 9 blocks: ML Landscape, Vocabulary, and Workspace Setup; Data Preparation and Feature Engineering for ML; Linear and Logistic Regression: Theory and Implementation; Decision Trees and Random Forests; Model Evaluation: Metrics, Cross-Validation, and ROC-AUC; Unsupervised Learning: K-Means Clustering; Common ML Failure Modes: Overfitting, Leakage, and Class Imbalance; ML Communication: Model Cards, Reproducibility, and Stakeholder Reporting; Capstone ML Project: End-to-End Build and Defense.

What competent looks like. Explain the difference between supervised, unsupervised, and reinforcement learning and select an appropriate algorithm family for a given business problem. Prepare a labeled dataset through train/validation/test splitting and basic feature engineering using pandas and scikit-learn pipelines. Train, tune, and evaluate classification and regression models using cross-validation, confusion matrices, ROC-AUC, RMSE, and R² metrics. Apply at least one unsupervised clustering algorithm (k-means) and interpret cluster assignments in a business context. Identify and mitigate common ML failure modes including data leakage, overfitting, and class imbalance. Produce a reproducible ML project notebook with documented methodology, model card, and a plain-language summary suitable for a professional portfolio.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	ML Landscape, Vocabulary, and Workspace Setup	9	theory	Students will categorize machine learning paradigms and configure a reproducible Python environment with scikit-learn, pandas, and Jupyter before any modeling begins.	Illustrated lecture and discussion mapping supervised, unsupervised, and reinforcement learning to real business use cases (spam detection, customer segmentation, recommendation engines); students annotate a concept map. Lab: install and verify Anaconda/conda environment, create a requirements.txt, confirm scikit-learn, pandas, matplotlib, and seaborn imports run without error in a shared Jupyter notebook. Small-group analysis of three published ML case studies (each from a different industry); groups present one risk and one benefit to the class, documented in a shared notes file.	Anaconda distribution, Jupyter Lab, scikit-learn docs (scikit-learn.org), 'Hands-On Machine Learning with Scikit-Learn, Keras & TensorFlow' (Géron) ch. 1, printed ML paradigm taxonomy handout	Exit ticket: student correctly classifies six problem statements into the right ML paradigm with written justification; 5 of 6 correct required to pass.
2	Data Preparation and Feature Engineering for ML	12	lab	Students will apply train/validation/test splitting, handle missing values, encode categorical variables, and scale numerical features inside a scikit-learn Pipeline object.	Instructor-led demo: load the UCI Adult Income dataset, profile missing values, and walk through a ColumnTransformer pipeline combining SimpleImputer, OneHotEncoder, and StandardScaler; students replicate step by step. Lab exercise: students receive a messy tabular dataset (housing or employee data) and must produce a clean, split, and transformed set of X_train, X_val, X_test arrays with a saved pipeline pickle file. Peer review: pairs exchange notebooks and verify that no test-set rows appear in the training pipeline fit step; document findings in a short leakage-check checklist.	Jupyter Lab, pandas, scikit-learn Pipeline/ColumnTransformer docs, UCI ML Repository datasets, leakage-check checklist handout	Instructor inspects notebook for correct split ratios (e.g., 70/15/15), absence of data leakage, and a runnable pipeline; all three criteria must be met for pass.
3	Linear and Logistic Regression: Theory and Implementation	12	demo	Students will train linear regression and logistic regression models, interpret coefficients, and evaluate results using RMSE/R² and accuracy/confusion matrix respectively.	Lecture with whiteboard derivation of ordinary least squares intuition and the logistic sigmoid function; students annotate slides with plain-language explanations they could use with a client. Guided coding demo: fit LinearRegression on a California housing sample, plot residuals, compute RMSE and R²; then fit LogisticRegression on the Titanic dataset, display a confusion matrix heatmap using seaborn. Individual mini-project: students choose one regression target and one classification target from a provided dataset list, fit both models, and write a five-sentence plain-language interpretation of each model's performance for a non-technical reader.	Jupyter Lab, scikit-learn, seaborn, matplotlib, statsmodels optional, California Housing and Titanic datasets (sklearn.datasets / Kaggle), Géron ch. 4	Mini-project notebook must show correct metric computation and a plain-language summary that accurately describes model limitations; instructor rubric requires ≥ 70% on a 10-point rubric to pass.
4	Decision Trees and Random Forests	12	lab	Students will train, visualize, and compare a decision tree and a random forest classifier, explain overfitting using depth hyperparameters, and rank feature importances.	Instructor demo: grow an unpruned decision tree on the Iris dataset, visualize it with sklearn.tree.plot_tree, observe overfit on training data vs. validation data; then repeat with max_depth restricted and compare metrics. Lab: students train a RandomForestClassifier on a provided medical or financial dataset, run a manual grid search over n_estimators and max_depth, plot validation curves, and produce a bar chart of the top 10 feature importances. Reflection journal entry (minimum 150 words): student explains in plain language why averaging many trees reduces variance and how they would explain random forests to a hiring manager unfamiliar with ML.	Jupyter Lab, scikit-learn, matplotlib, Géron ch. 6–7, provided dataset (e.g., Heart Disease UCI or Credit Approval UCI)	Lab notebook must include validation curve plot showing overfitting trend, a tuned model with documented best hyperparameters, and feature importance chart; all three artifacts required plus ≥ 70% rubric score.
5	Model Evaluation: Metrics, Cross-Validation, and ROC-AUC	12	theory	Students will select appropriate evaluation metrics for classification and regression problems, implement k-fold cross-validation, and construct and interpret ROC curves.	Lecture and guided problem set: students work through four scenario cards (imbalanced classes, high false-negative cost, continuous target, ordinal target) and justify which metric to use in each case, citing precision, recall, F1, ROC-AUC, RMSE, or MAE. Coding lab: use cross_val_score and StratifiedKFold on the Titanic logistic regression from Lesson 3; plot the ROC curve using RocCurveDisplay, compute AUC, and annotate the plot with the operating point selected and the business rationale. Group debate (10 minutes): two teams argue whether accuracy or ROC-AUC is more useful for a fraud-detection model; instructor summarizes consensus and students update their concept maps.	Jupyter Lab, scikit-learn metrics module documentation, scenario cards (instructor-prepared), Géron ch. 3	Individual scenario card quiz (4 questions, open-note): student must correctly match metric to scenario with written justification for all 4; plus cross-validation notebook cell must produce a mean ± std score without errors.
6	Unsupervised Learning: K-Means Clustering	12	lab	Students will apply k-means clustering to an unlabeled dataset, use the elbow method and silhouette score to select k, and communicate cluster profiles to a business audience.	Instructor demo: cluster the Mall Customers dataset (or similar retail dataset) with KMeans for k=2 through k=10, plot inertia (elbow curve) and silhouette scores, and select optimal k; students follow along and annotate. Lab: students cluster a city public-dataset (e.g., 311 service requests or library usage by ZIP code) provided by the instructor, produce a scatter plot with cluster color coding, and compute summary statistics for each cluster. Business memo exercise: students write a one-page plain-language memo addressed to a fictional city department director explaining what each cluster represents and one actionable recommendation per cluster.	Jupyter Lab, scikit-learn KMeans, yellowbrick library for visualizations, publicly available city dataset (instructor-curated), Mall Customers CSV	Lab assessed on: correct elbow/silhouette plot, justified k selection, color-coded cluster scatter plot, and a memo with at least one data-backed recommendation per cluster; ≥ 70% on rubric required.
7	Common ML Failure Modes: Overfitting, Leakage, and Class Imbalance	12	practice	Students will diagnose overfitting, data leakage, and class imbalance in provided flawed notebooks and apply remediation techniques including regularization, SMOTE/class weights, and pipeline restructuring.	Instructor presents three deliberately broken notebooks (one each for overfitting, leakage, and severe class imbalance); student pairs perform a 'code review' using a structured checklist and document each bug and its effect on reported metrics. Hands-on remediation: students fix the overfitting notebook by adding L2 regularization (ridge) or max_depth constraint, fix the leakage notebook by moving scaling inside the pipeline, and fix the imbalanced notebook using class_weight='balanced' or SMOTE from imbalanced-learn; re-run and compare before/after metrics. Class debrief: each group presents one fix; instructor leads discussion connecting these failure modes to real-world ML disasters (e.g., model deployed on distribution-shifted data); students add a 'red flags' section to their concept maps.	Jupyter Lab, scikit-learn, imbalanced-learn (imblearn), instructor-prepared broken notebooks, code-review checklist handout, Géron ch. 1–2 on ML pitfalls	Each remediated notebook must show improved validation metric (e.g., reduced overfit gap, improved minority-class recall) and include an inline markdown comment explaining what was wrong and how it was fixed; all three notebooks required at ≥ 70% rubric.
8	ML Communication: Model Cards, Reproducibility, and Stakeholder Reporting	12	practice	Students will produce a complete model card, a reproducible notebook with seeded randomness and version-pinned dependencies, and a slide deck summarizing model findings for a non-technical audience.	Guided reading and discussion: review Google's Model Card template (modelcards.withgoogle.com) and two published model cards; students identify which sections align with CompTIA Data+ domain of 'communicating results' and IBM Data Science Professional portfolio standards. Lab: students select one model built in a prior lesson and complete a full model card covering intended use, training data description, performance metrics disaggregated by any available subgroups, and known limitations; set random_state seeds throughout the notebook and pin package versions in requirements.txt. Create a five-slide summary deck (PowerPoint or Google Slides) targeting a city council audience: one slide each for problem statement, data used, model approach (plain language), key metric, and one business recommendation; present to a partner who plays the role of a non-technical director.	Google Model Card template, Google Slides or PowerPoint, Jupyter Lab, pip freeze / conda list for dependency pinning, IBM Data Science Professional portfolio guidelines	Model card must address all required sections; notebook must run from top to bottom without errors on a clean environment; slide deck must avoid unexplained jargon (peer and instructor check); ≥ 70% on combined rubric.
9	Capstone ML Project: End-to-End Build and Defense	9	lab	Students will independently complete a documented end-to-end ML pipeline on an unseen dataset, present findings in a 10-minute defense, and respond to evaluator questions.	Students receive an instructor-curated dataset on Day 1 of this lesson block; independently perform EDA, feature engineering, model selection, hyperparameter tuning, and final evaluation; submit a complete Jupyter notebook and model card 48 hours before defense. Ten-minute oral defense before a panel of at least two evaluators (instructor plus one peer or external reviewer): student presents problem framing, methodology, metric results, and at least one failure mode encountered and how it was addressed. Post-defense written reflection (minimum 200 words): student describes one thing they would do differently if given more time and maps their project steps to at least two credential exam domains (CompTIA Data+, IBM Data Science Professional, or Google Data Analytics).	Instructor-curated dataset (held out until lesson day), Jupyter Lab, scikit-learn, presentation slides, model card template, rubric distributed in advance	Panel uses a 20-point rubric covering: data preparation quality (5), model selection justification (5), metric reporting accuracy (5), and clarity of defense communication (5); minimum 14/20 to pass; written reflection must be submitted within 24 hours of defense.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
ML Concepts Knowledge Exam	Written exam	25%	70% or higher (35 of 50 points)	A 50-question closed-book exam covering ML paradigm classification, algorithm selection, metric definitions, cross-validation mechanics, and common failure modes, mapped to CompTIA Data+ Domain 4 (Analysis) and IBM Data Science Professional knowledge areas. Questions are multiple choice and short answer; students have 90 minutes. Standard met · Safety · Time · Quality/finish · Documentation
End-to-End ML Pipeline Skills Demonstration	Skills demonstration	45%	14 of 20 rubric points; all required artifacts submitted	Students independently build and defend a complete ML pipeline on an instructor-supplied dataset within a defined time window, producing a runnable Jupyter notebook, a model card, and a five-slide stakeholder deck; a panel evaluates methodology, metric accuracy, and communication clarity as described in Lesson 9. Standard met · Safety · Time · Quality/finish · Documentation
Lab Notebook Portfolio Log	Log	15%	At least 7 of 9 lesson notebooks submitted and scored ≥ 70% on their individual rubrics	All lesson lab notebooks are collected as a portfolio; each is evaluated for correct code execution, presence of required visualizations or outputs, inline markdown explanations, and reproducibility (seeded randomness, no data leakage); the portfolio log documents the instructor's check date and score for each submission. Standard met · Safety · Time · Quality/finish · Documentation
Workspace and Data Safety Check	Safety audit	15%	Pass/Fail — all mandatory items must be marked 'Pass'; any single 'Fail' requires immediate correction and re-check before the student proceeds	Instructor uses a standardized checklist to verify that each student's workspace and workflow meet safety and professional standards: no sensitive or personally identifiable data stored in plain text in shared repositories, no unlicensed datasets in use, conda/virtual environment isolation confirmed, and the student can verbally explain data governance obligations applicable to their ML project data under applicable privacy principles covered in the program. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-09 Trade course

GIS and Spatial Data Analysis

102 hr · ~~$1,225~~ COMPLIMENTARY

Students learn to acquire, process, analyze, and visualize geographic and spatial data using industry-standard GIS tools including QGIS, ArcGIS Online, and Python spatial libraries. The course covers coordinate reference systems, spatial joins, raster and vector data, and the production of professional-quality maps and spatial dashboards. Spatial analysis skills are directly applicable to the Google Data Analytics, IBM Data Science Professional, and CompTIA Data+ credential exam domains covering data types, visualization, and analytical techniques.

Outcomes

Load, reproject, and perform attribute and spatial queries on vector and raster datasets using QGIS and Python (GeoPandas/Shapely).
Explain coordinate reference systems and apply appropriate projections for area, distance, and direction measurements.
Execute spatial operations including buffering, intersection, spatial joins, and choropleth classification to answer a defined analytical question.
Connect live spatial data feeds and web map services (WMS/WFS/REST) and publish an interactive web map using ArcGIS Online or an equivalent open platform.
Document a complete spatial analysis workflow in a reproducible Jupyter Notebook with narrative, code, and embedded map outputs.
Interpret map output for a non-technical audience and evaluate a peer's spatial analysis for methodological accuracy and ethical data use.

Course text

How the course runs. 9 blocks: Spatial Thinking and GIS Fundamentals; Coordinate Reference Systems and Projections; Vector Data: Loading, Querying, and Editing; Raster Data and Remote Sensing Basics; Spatial Operations: Buffers, Intersections, and Spatial Joins; Python for Spatial Data: GeoPandas, Shapely, and Folium; Cartographic Design and Map Production; Web GIS and Spatial Dashboards; Spatial Analysis Capstone Project: End-to-End Workflow.

What competent looks like. Load, reproject, and perform attribute and spatial queries on vector and raster datasets using QGIS and Python (GeoPandas/Shapely). Explain coordinate reference systems and apply appropriate projections for area, distance, and direction measurements. Execute spatial operations including buffering, intersection, spatial joins, and choropleth classification to answer a defined analytical question. Connect live spatial data feeds and web map services (WMS/WFS/REST) and publish an interactive web map using ArcGIS Online or an equivalent open platform. Document a complete spatial analysis workflow in a reproducible Jupyter Notebook with narrative, code, and embedded map outputs. Interpret map output for a non-technical audience and evaluate a peer's spatial analysis for methodological accuracy and ethical data use.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Spatial Thinking and GIS Fundamentals	10	theory	Students will correctly define GIS core concepts—layers, features, attributes, topology, and scale—and explain how spatial data differs from tabular data.	Concept lecture with annotated slide decks covering GIS history, real-world use cases (public health mapping, urban planning, logistics), and layer-based data model; students annotate a printed example map identifying at least six spatial concepts. Small-group discussion: students compare a CSV of restaurant addresses to a point shapefile of the same data, listing three limitations of tabular-only analysis and three advantages of spatial representation. Individual written response (minimum 300 words) describing a data question from their field of interest that would benefit from spatial analysis, naming the data layers they would need and the spatial question they would ask.	QGIS 3.x installed on lab computers, ESRI ArcGIS Online free public account, 'Introduction to GIS' chapter from Longley et al. 'Geographic Information Science and Systems' (course library copy), sample city parcel shapefile (publicly available from local government open-data portal), printed world map with graticule	Exit-ticket quiz of 10 multiple-choice questions on GIS vocabulary and layer types; pass mark 70%. Instructor reviews written responses for correct identification of at least two required spatial layers.
2	Coordinate Reference Systems and Projections	10	theory	Students will select an appropriate projected coordinate reference system (CRS) for a given analytical task and reproject a dataset in QGIS without geometric distortion errors.	Instructor-led demonstration comparing geographic (latitude/longitude, WGS84 EPSG:4326) versus projected CRS (e.g., State Plane, UTM zones) using QGIS 'on-the-fly' reprojection; students sketch a diagram of how a globe is 'unwrapped' onto a flat plane. Guided lab: students load three layers with mismatched CRSs, identify the mismatch using the QGIS layer properties panel, reproject all to a common projected CRS appropriate for their state (using EPSG lookup at epsg.io), and verify alignment by overlaying a streets layer. Pair activity: each pair receives a spatial scenario card (e.g., 'measure acreage of city parks,' 'map sea-level rise risk') and must argue in writing which CRS is most appropriate and why, referencing distortion properties (area, shape, distance, direction).	QGIS 3.x, epsg.io reference site, US Census TIGER/Line shapefiles (publicly available), projection comparison handout adapted from USGS 'Map Projections—A Working Manual' public domain content, printed CRS cheat sheet	Students submit a QGIS project file with three layers correctly reprojected to a single CRS and a one-paragraph explanation of their CRS choice. Instructor checks that the layer extents align visually and that the CRS choice is defensible; pass mark: correct reprojection plus justification scoring 3/4 on a rubric.
3	Vector Data: Loading, Querying, and Editing	12	lab	Students will perform attribute queries, spatial queries, and basic feature editing on vector data (points, lines, polygons) in QGIS, exporting results as a new shapefile or GeoJSON.	Instructor demo of the QGIS attribute table, Select by Expression tool, and the Query Builder using a public crime or permit dataset; students follow along on their own machines and record the SQL-like expressions used. Individual lab: students load a city open-data polygon layer (e.g., census tracts) and a point layer (e.g., public schools), run attribute queries to filter features meeting specified criteria, and use 'Select by Location' to identify all schools within a specified census tract; they export results as GeoJSON. Editing exercise: students add three new point features to an existing layer (e.g., locations of community centers identified from a reference map), populate attributes including name and category, and save edits; a partner reviews the attribute table for completeness.	QGIS 3.x, US Census TIGER/Line shapefiles, city or county open-data portal shapefiles (pre-downloaded), QGIS Training Manual (open-source, qgis.org), lab worksheet with step-by-step instructions and expected outputs	Students submit: exported GeoJSON file with correct filtered features, a screenshot of the Select by Location result, and the edited layer. Instructor checks that the GeoJSON contains only records matching the query criteria and that new features have fully populated attributes; pass mark: all three deliverables correct and complete.
4	Raster Data and Remote Sensing Basics	10	demo	Students will load, visualize, and perform basic raster analysis (reclassification, zonal statistics) on a satellite or elevation raster in QGIS.	Instructor-led demonstration explaining raster data model (cells, bands, resolution, NoData values) using a USGS Digital Elevation Model (DEM) and a Landsat band composite; students label a printed diagram identifying pixel size, extent, and band. Guided demo-then-do: instructor performs raster reclassification (grouping elevation values into low/medium/high classes) live, then students replicate the workflow independently on the same dataset and compare their classified output to the instructor's reference map. Zonal statistics exercise: students overlay a polygon layer (census tracts or watersheds) on a raster layer (elevation or NDVI), run the QGIS Zonal Statistics tool, and interpret the resulting mean values per polygon in a brief written paragraph, noting which zone has the highest and lowest mean value and a possible geographic explanation.	QGIS 3.x with SAGA and GDAL processing providers enabled, USGS National Elevation Dataset (NED) 1/3 arc-second DEM tile (publicly available from USGS EarthExplorer), Landsat 8 OLI sample scene (free from USGS EarthExplorer), QGIS Raster Analysis documentation (qgis.org)	Students submit their classified raster as a GeoTIFF and their zonal statistics paragraph. Instructor verifies the reclassification has at least three classes with correct value ranges and that the paragraph references specific numeric outputs; pass mark: correct reclassification plus paragraph with at least two accurate numeric citations from their output.
5	Spatial Operations: Buffers, Intersections, and Spatial Joins	14	lab	Students will apply at least three spatial operations (buffer, intersect, spatial join) to answer a defined analytical question and document each processing step.	Instructor demonstration of the QGIS geoprocessing toolbox: buffer, clip, intersect, union, and spatial join; students take notes in a workflow diagram template, labeling inputs, tool, and output for each operation shown. Analytical lab: given a scenario ('Identify all parcels within 500 feet of a floodplain and count how many are residential'), students independently build a workflow using buffer → intersect → attribute query → summarize, documenting each step with tool settings and a screenshot of intermediate outputs. Peer review: students exchange their documented workflows and attempt to replicate the partner's analysis using only the documented steps; they flag any step that was unclear or produced a different result, then discuss discrepancies as a class.	QGIS 3.x, FEMA National Flood Hazard Layer (NFHL) shapefile (publicly available from FEMA Map Service Center), county parcel shapefile from open-data portal, QGIS Geoprocessing Algorithms documentation, workflow diagram template (instructor-prepared)	Students submit the workflow documentation and the final output shapefile. Instructor checks that the buffer distance matches the scenario, that the intersect output contains only features meeting both conditions, and that documentation is detailed enough for a peer to replicate; pass mark: correct output layer plus documentation rated 3/4 on a reproducibility rubric.
6	Python for Spatial Data: GeoPandas, Shapely, and Folium	16	lab	Students will read, manipulate, and spatially analyze vector data using GeoPandas and Shapely in a Jupyter Notebook, and render an interactive web map using Folium.	Code-along: instructor opens a Jupyter Notebook and walks through reading a GeoJSON file into a GeoDataFrame, inspecting CRS, filtering rows with Pandas-style boolean indexing, and computing a new column (e.g., area in square meters using projected CRS); students type and run each cell, adding markdown commentary. Independent coding exercise: students use GeoPandas to perform a spatial join between a point GeoDataFrame (e.g., library locations) and a polygon GeoDataFrame (census tracts), compute the count of libraries per tract, and merge the result back to the tract GeoDataFrame for choropleth mapping. Folium mapping task: students build an interactive Folium map displaying their choropleth layer with a tooltip showing tract ID and library count, add a tile layer, and export the map as an HTML file; they open it in a browser and screenshot three zoom levels.	Python 3.x with GeoPandas, Shapely, Folium, Matplotlib installed (via course Anaconda environment), Jupyter Notebook, GeoPandas documentation (geopandas.org), Folium documentation (python-visualization.github.io/folium), US Census TIGER/Line GeoJSON files, library location GeoJSON from city open-data portal	Students submit their Jupyter Notebook (.ipynb) with all cells executed and the exported Folium HTML file. Instructor checks that the spatial join produces correct feature counts, the choropleth classification is applied correctly, and the Folium map loads and displays tooltips; pass mark: all three deliverables correct, notebook runs top-to-bottom without errors.
7	Cartographic Design and Map Production	10	practice	Students will design and export a publication-quality map in QGIS that correctly applies cartographic principles including a legend, north arrow, scale bar, title, and appropriate color scheme.	Lecture on cartographic design principles: visual hierarchy, color theory (sequential, diverging, and qualitative schemes using ColorBrewer), symbol choice, label placement, and map element requirements; students critique three example maps (two poor, one strong) using a structured rubric. Map layout exercise: students open the QGIS Print Layout, add a previously completed analysis layer, and construct a map with all required elements (title, legend, north arrow, scale bar, source citation, CRS label); they apply a ColorBrewer sequential color ramp appropriate to their data type. Peer critique: students display their maps side by side (printed or on screen) and exchange structured written feedback covering five cartographic criteria; each student revises at least two elements based on feedback before final export.	QGIS 3.x Print Layout, ColorBrewer (colorbrewer2.org), Slocum et al. 'Thematic Cartography and Geovisualization' (course library copy), map critique rubric (instructor-prepared), color printer or large-format display	Students submit a PDF map export. Instructor evaluates using the five-criterion cartographic rubric (title, legend, north arrow/scale bar, color scheme appropriateness, label legibility); pass mark: score of 4/5 criteria rated 'meets standard' or higher.
8	Web GIS and Spatial Dashboards	12	practice	Students will publish a spatial dataset to ArcGIS Online (or an equivalent open platform such as CARTO or Felt), configure a hosted feature layer, and embed it in an interactive web map or dashboard shared via a public URL.	Instructor demo: sign in to ArcGIS Online free public account, upload a GeoJSON file to create a hosted feature layer, configure pop-ups with field aliases and formatted attributes, and set a symbol renderer; students follow along step by step. Individual project: students publish their spatial join output from Lesson 6 to ArcGIS Online, configure meaningful pop-ups, apply a graduated color renderer, and create a web map with a descriptive title and summary; they share the item publicly and paste the URL into a submission form. Dashboard extension (where platform supports): students add at least one chart widget (bar chart or pie chart) linked to the map selection so that clicking a feature updates the chart; they screenshot the linked interaction and write two sentences explaining what an end user can learn from the linked view.	ArcGIS Online free public account (esri.com) or CARTO free tier, web browser, previously completed GeoJSON from Lesson 6, ArcGIS Online Help documentation (doc.arcgis.com), instructor-prepared step-by-step platform guide	Students submit the public URL and a screenshot of the published web map. Instructor loads the URL and checks for: hosted feature layer with correct data, graduated renderer, pop-ups with at least three fields, and (if dashboard attempted) a linked chart; pass mark: all three core elements present and map loads correctly in an incognito browser window.
9	Spatial Analysis Capstone Project: End-to-End Workflow	8	lab	Students will independently complete a full spatial analysis workflow—data acquisition, cleaning, spatial operations, visualization, and interpretation—on a self-selected public dataset and present findings to the class.	Project kick-off and proposal: students select a publicly available spatial dataset relevant to a real-world question (e.g., food-access deserts, transit coverage gaps, green-space equity), submit a one-page proposal identifying the data sources, analytical question, planned spatial operations, and intended audience; instructor approves before work begins. Independent analysis sprint: students complete the full workflow in QGIS and/or Python over a multi-session period, maintaining a lab log of each session including decisions made, errors encountered, and how they were resolved; instructor circulates and provides formative feedback. Five-minute class presentation with map output: each student displays their final map or web map, states the analytical question, explains the spatial operations performed, presents the key finding in one sentence, and takes one question from a classmate; a self-assessment rubric is completed immediately after.	QGIS 3.x, Python/Jupyter Notebook, ArcGIS Online or Folium for web output, any publicly available spatial data (US Census, USGS, CDC PLACES, city open-data portals), lab log template (instructor-prepared), presentation rubric	Instructor evaluates: submitted lab log (completeness and honest error documentation), final map/web map (cartographic quality, correct spatial operations), and presentation (clarity of question and finding); pass mark: lab log rated complete, map scores 4/5 on cartographic rubric, and presentation clearly states a defensible finding.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
GIS Concepts and Methods Knowledge Exam	Written exam	25%	70% or higher (28 of 40 points)	A 40-question written exam covering GIS concepts, coordinate reference systems, data types (vector and raster), spatial operations, cartographic principles, and Python spatial libraries as introduced across all nine lessons; questions are multiple-choice and short-answer. Mapped to CompTIA Data+ Domain 2 (Data Analysis) and Domain 4 (Visualization), IBM Data Science Professional data analysis and visualization competencies, and Google Data Analytics Certificate data processing and visualization domains. Standard met · Safety · Time · Quality/finish · Documentation
Spatial Analysis Skills Demonstration	Skills demonstration	45%	Score of 18/25 or higher on the five-criterion skills rubric	Within a 90-minute timed session, students receive a new public spatial dataset and a written analytical question; they must complete a spatial join or buffer-intersect workflow in QGIS or Python, produce a publication-quality map with all required cartographic elements, and publish it to a web platform—submitting the map PDF and public URL. Mapped to IBM Data Science Professional hands-on project competencies and Google Data Analytics Certificate data visualization and presentation domains. Standard met · Safety · Time · Quality/finish · Documentation
Spatial Analysis Lab Log	Log	15%	Rated 'meets standard' on all four rubric criteria	Students submit the cumulative lab log maintained throughout Lessons 3, 5, 6, and 9, documenting session goals, datasets used, tools and parameters applied, errors and resolutions, and analytical decisions made; entries must be sufficiently detailed for a third party to reproduce the work. Mapped to CompTIA Data+ Domain 1 (Data Concepts and Environments) documentation expectations and IBM Data Science Professional reproducibility competencies. Standard met · Safety · Time · Quality/finish · Documentation
Workplace and Digital Safety Check	Safety audit	15%	100% on all mandatory safety behaviors; any failure requires immediate remediation and recheck	Instructor observes each student during a lab session and checks against a printed checklist covering: correct handling and citation of licensed versus open-license spatial data (copyright compliance), proper management of datasets containing personally identifiable location information (PII) in accordance with course privacy guidelines, ergonomic workstation setup per OSHA general industry guidelines, and correct file backup and version-control practices to prevent data loss. Students also verbally answer two scenario questions about what to do if they discover a dataset contains sensitive individual-level location data. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-10 Trade course

Ethics & Privacy in Data Science and Analytics

102 hr · ~~$1,225~~ COMPLIMENTARY

This course equips data science and analytics practitioners with the legal, ethical, and technical knowledge required to collect, store, process, and publish data responsibly. Students examine foundational privacy frameworks, bias and fairness in algorithmic systems, data governance best practices, and the professional codes of conduct relevant to the field. Lessons align with the ethics and compliance competencies tested in the Google Data Analytics Certificate, CompTIA Data+, IBM Data Science Professional, and Microsoft PL-300 exam domains.

Outcomes

Identify applicable US and international data privacy laws and regulations and explain their practical requirements for a data analytics workflow.
Detect, quantify, and mitigate sources of bias in datasets and machine-learning outputs using established fairness metrics.
Design and document a data governance plan that includes data classification, access controls, retention schedules, and breach-response procedures.
Apply anonymization, pseudonymization, and aggregation techniques to a real dataset to reduce re-identification risk while preserving analytical utility.
Evaluate an analytics product or dashboard against a professional code of ethics and produce a written compliance assessment.
Communicate privacy and ethical risk findings clearly to both technical and non-technical stakeholders using written reports and verbal presentations.

Course text

How the course runs. 9 blocks: Foundations of Data Ethics and Professional Codes of Conduct; US and International Data Privacy Law; Informed Consent, Data Minimization, and Purpose Limitation; Data Classification, Governance, and Access Control; Anonymization, Pseudonymization, and Aggregation Techniques; Algorithmic Bias: Detection, Measurement, and Mitigation; Responsible Visualization and Communication of Data; Data Breach Response, Incident Reporting, and Organizational Responsibility; Ethics Audit: Integrated Assessment of a Published Analytics Product.

What competent looks like. Identify applicable US and international data privacy laws and regulations and explain their practical requirements for a data analytics workflow. Detect, quantify, and mitigate sources of bias in datasets and machine-learning outputs using established fairness metrics. Design and document a data governance plan that includes data classification, access controls, retention schedules, and breach-response procedures. Apply anonymization, pseudonymization, and aggregation techniques to a real dataset to reduce re-identification risk while preserving analytical utility. Evaluate an analytics product or dashboard against a professional code of ethics and produce a written compliance assessment. Communicate privacy and ethical risk findings clearly to both technical and non-technical stakeholders using written reports and verbal presentations.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Foundations of Data Ethics and Professional Codes of Conduct	10	theory	Students will explain core ethical principles — beneficence, non-maleficence, autonomy, justice, and transparency — and map them to at least two published professional codes of conduct relevant to data science.	Read and annotate excerpts from the ACM Code of Ethics and Professional Conduct and the ASA Ethical Guidelines for Statistical Practice; complete a guided note-taking template identifying how each principle appears in real-world data work. Case-study analysis: review three published data-ethics failures (such as discriminatory hiring algorithms, biased health-risk scoring, and location-data misuse) and write a one-page explanation of which ethical principle was violated and what a practitioner could have done differently. Small-group Socratic discussion: each group defends or critiques a scenario where analytical accuracy conflicts with individual privacy, then presents conclusions to the class.	ACM Code of Ethics (acm.org), ASA Ethical Guidelines (amstat.org), Harvard Business Review case studies on algorithmic harm, whiteboard, discussion rubric	Each student submits a written analysis of one assigned case study; graded on accurate identification of the violated principle, plausibility of the proposed remedy, and clarity of writing. Pass mark: 75% on a 20-point rubric.
2	US and International Data Privacy Law	12	theory	Students will summarize the key requirements of major US and international privacy regulations and identify which requirements apply to a given data-analytics scenario.	Lecture and annotated reading covering the general structure of HIPAA (health data), FERPA (education data), COPPA (children's data), CCPA/CPRA (California consumer privacy), and GDPR (EU framework applicable to US organizations handling EU residents' data); students complete a comparison matrix for each law's scope, data-subject rights, and penalties. Regulatory mapping exercise: given three fictional business data-analytics projects — a hospital readmission predictor, a K-12 attendance dashboard, and a retail personalization engine — students identify which laws apply and list at least four specific compliance obligations for each project. Peer review: students exchange their regulatory mapping documents and provide written feedback on accuracy and completeness, then revise based on feedback.	FTC plain-language COPPA summary, HHS HIPAA for Professionals page, California DOJ CCPA resources, GDPR text summary from the IAPP (iapp.org), comparison matrix template	Regulatory mapping exercise graded for accuracy of law identification and completeness of listed obligations; instructor checks that HIPAA, FERPA, COPPA, CCPA/CPRA, and GDPR are each correctly addressed. Pass mark: 75% correct on a structured 20-item checklist.
3	Informed Consent, Data Minimization, and Purpose Limitation	10	demo	Students will design a data-collection instrument — survey form or API data-pull specification — that includes a valid informed-consent mechanism, collects only the minimum necessary fields, and restricts use to a declared purpose.	Instructor demonstration: live walk-through of a Google Forms survey build that includes a compliant informed-consent preamble, checkboxes for granular permission, and a purpose statement; students observe and take structured notes using a provided checklist. Hands-on redesign: students receive a poorly designed data-collection form missing consent language and collecting excessive fields; they revise it to include all required consent elements, remove non-essential fields, and add a purpose clause, then annotate each change. Partner critique: pairs exchange redesigned forms and evaluate them against a provided rubric, discussing at least two remaining risk areas before submitting a final version.	Google Forms or Microsoft Forms (browser-based, no install needed), provided flawed-form handout, consent-language checklist adapted from GDPR Article 7 and CCPA guidance, annotation rubric	Instructor reviews final redesigned form against the 10-point consent checklist: valid consent preamble present, granular opt-in included, excessive fields removed, purpose statement included, and right-to-withdraw stated. Pass mark: 8 of 10 checklist items met.
4	Data Classification, Governance, and Access Control	12	lab	Students will create a data governance plan for a provided dataset that includes a data dictionary, a four-tier classification scheme, role-based access control definitions, a retention schedule, and a breach-notification outline.	Lab setup: students receive a realistic synthetic dataset (city health-clinic visits with names, ZIP codes, diagnoses, and insurance codes) in CSV form; they first audit the dataset and build a complete data dictionary documenting each field's name, type, description, and sensitivity level. Classification and RBAC assignment: students assign each field to one of four sensitivity tiers (public, internal, confidential, restricted), then define at least three user roles (analyst, manager, external auditor) with specific read/write/export permissions per tier using a provided RBAC template. Governance document assembly: students compile their data dictionary, classification matrix, retention schedule (with justification referencing HIPAA or applicable law), and a one-page breach-notification flowchart into a single governance plan document, formatted for a non-technical supervisor audience.	Synthetic health-clinic CSV file (instructor-created, no real PHI), RBAC template spreadsheet, NIST SP 800-188 data de-identification guidance (publicly available), Google Docs or Microsoft Word, provided governance plan outline	Governance plan evaluated on six criteria: complete data dictionary, accurate four-tier classification, logical RBAC definitions, retention schedule with legal justification, breach-notification flowchart, and professional formatting. Pass mark: 75% across a 24-point rubric (4 points per criterion).
5	Anonymization, Pseudonymization, and Aggregation Techniques	14	lab	Students will apply at least four de-identification techniques — direct identifier removal, generalization, suppression, and k-anonymity — to a provided dataset in Python or R, and measure the resulting re-identification risk and information loss.	Guided coding exercise: instructor-provided Python notebook walks students through removing direct identifiers (name, SSN, exact address), then generalizing quasi-identifiers (exact age → age band, full ZIP → 3-digit ZIP) on the synthetic health dataset; students run each step and record the output in their lab log. k-Anonymity implementation: students write Python code (using pandas) to verify that every combination of quasi-identifiers in the modified dataset appears at least k=5 times; they identify any records failing the k=5 threshold and apply suppression or further generalization until the threshold is met, documenting each decision. Utility vs. privacy trade-off analysis: students run three pre-specified summary statistics (mean age by diagnosis group, visit counts by ZIP, insurance type distribution) on both the original and de-identified dataset, compute the percentage difference for each statistic, and write a one-paragraph conclusion about acceptable information loss.	Jupyter Notebook or RStudio, pandas library, synthetic health-clinic CSV, NIST SP 800-188 de-identification guide, ARX Data Anonymization Tool (open-source, arx.deidentifier.org) for validation cross-check, lab log template	Lab log reviewed for: correct execution of all four techniques with working code, k=5 anonymity achieved and verified, percentage-difference calculations correct, and trade-off paragraph demonstrating reasoned judgment. Pass mark: all four techniques correctly applied and k-anonymity verified; 75% on a 20-point rubric overall.
6	Algorithmic Bias: Detection, Measurement, and Mitigation	14	lab	Students will identify at least two sources of bias in a provided machine-learning pipeline, calculate at least three fairness metrics (demographic parity, equalized odds, and predictive parity), and apply one mitigation strategy, comparing metrics before and after.	Bias audit: students load a provided pre-trained binary classification model and its test dataset (synthetic loan-approval data with demographic attributes) into a Jupyter Notebook; they compute confusion matrices separately for two demographic groups and calculate demographic parity difference, equalized odds difference, and predictive parity, interpreting each value against a threshold of 0.10. Root-cause analysis: students trace bias back to the training data and feature set by examining class imbalance, missing-value patterns by group, and proxy features (for example, ZIP code as a proxy for race); they document findings in a structured bias-audit report template. Mitigation and re-evaluation: students apply one pre-processing mitigation — reweighting training samples using the imbalanced-learn library or removing the most problematic proxy feature — then retrain the model and recalculate the three fairness metrics, presenting a before/after comparison table with a written interpretation.	Jupyter Notebook, scikit-learn, imbalanced-learn, Fairlearn library (fairlearn.org), synthetic loan-approval dataset (instructor-created), bias-audit report template, Barocas et al. Fairness and Machine Learning textbook (free at fairmlbook.org)	Bias-audit report and before/after comparison table reviewed by instructor; pass requires all three fairness metrics correctly calculated before mitigation, at least one mitigation applied with documented rationale, and metrics recalculated correctly after mitigation. Pass mark: 75% on a 20-point rubric.
7	Responsible Visualization and Communication of Data	12	practice	Students will identify at least five misleading visualization practices in provided examples and redesign one flawed chart into a truthful, accessible, and clearly labeled alternative suitable for a public-facing audience.	Visual audit exercise: students receive a packet of eight real-world charts collected from news and government sources (instructor-curated, all publicly available) that contain common distortions — truncated y-axes, cherry-picked date ranges, dual-axis manipulation, cherry-picked samples, and color choices that imply value judgments; they annotate each chart to name the misleading practice and explain its effect on interpretation. Redesign workshop: each student selects one of the audited charts and rebuilds it in Tableau Public or Power BI Desktop using the underlying data provided; the redesign must include a truthful axis, complete data range, descriptive title, data source citation, and an alt-text description for accessibility. Gallery walk and peer critique: students post their redesigned charts (printed or projected) and rotate through at least four peers' work, leaving sticky-note feedback on one strength and one area for improvement for each; students incorporate at least one piece of feedback before final submission.	Tableau Public (free) or Power BI Desktop (free), provided chart-audit packet (PDFs), Cairo A. The Truthful Art (reference), WCAG 2.1 color-contrast checker (WebAIM), redesign rubric	Redesigned chart graded on: accurate axis and data range, complete labels and source citation, removal of original misleading element documented in a caption, and functional alt-text. Pass mark: all four criteria met at a satisfactory level per a 16-point rubric; 75% required.
8	Data Breach Response, Incident Reporting, and Organizational Responsibility	10	practice	Students will execute a tabletop breach-response simulation, producing an incident timeline, a stakeholder notification draft, and a post-incident remediation plan that addresses the root cause.	Tabletop simulation: instructor presents a multi-stage data-breach scenario — an analyst's misconfigured cloud storage bucket exposes 10,000 patient records; students in teams of three work through a provided incident-response playbook, assigning roles (incident lead, communications lead, technical lead) and completing a decision tree at each stage of the scenario. Notification drafting: each student individually drafts a breach notification letter to affected individuals that meets the general requirements of the HIPAA Breach Notification Rule (plain language, description of incident, types of information exposed, steps individuals should take, contact information for questions), referencing the provided regulatory summary. Remediation plan: teams collaboratively write a one-page post-incident remediation plan identifying the root cause (misconfigured access control), three corrective technical controls (e.g., bucket access audit, MFA enforcement, automated misconfiguration alerts), and a 30-day implementation timeline.	Incident-response playbook template (instructor-created), HHS Breach Notification Rule plain-language summary (hhs.gov), NIST SP 800-61r2 Computer Security Incident Handling Guide (publicly available PDF), notification letter template, remediation plan template	Notification letter graded against a six-item checklist (plain language, incident description, data types identified, recommended actions listed, contact provided, sent within required general timeframe). Remediation plan graded on root-cause accuracy and plausibility of controls. Pass mark: 5 of 6 notification checklist items met and at least two plausible technical controls documented.
9	Ethics Audit: Integrated Assessment of a Published Analytics Product	8	practice	Students will independently conduct a structured ethics audit of a publicly available analytics dashboard or published dataset, producing a written report that evaluates privacy, bias, governance, and communication ethics, and presents findings in a brief oral defense.	Audit execution: each student selects one publicly available analytics product from a provided list of options (e.g., a city open-data dashboard, a published government equity report, a public health data portal) and applies a structured audit checklist covering data sourcing and consent, data minimization, bias risk, visualization honesty, accessibility, and disclosed limitations. Written report: students compile their audit findings into a 1,000-to-1,500-word professional report structured with an executive summary, methodology, findings by ethical category, risk ratings (low/medium/high), and specific, actionable recommendations for each identified risk. Oral defense: each student presents their report in a five-minute presentation followed by five minutes of instructor and peer questions; students must clearly connect at least two findings to a specific regulation or code-of-ethics provision discussed in the course.	Provided list of approved public analytics products, ethics audit checklist (instructor-created, drawing on ACM Code, ASA Guidelines, and GDPR principles), report template, presentation slide template	Written report graded on: audit checklist fully completed, findings accurately categorized by ethical domain, risk ratings justified with evidence, and at least three actionable recommendations. Oral defense graded on clarity, accurate citation of at least two regulatory or ethical standards, and ability to answer follow-up questions. Pass mark: 75% on a combined 32-point rubric (20 report, 12 defense).

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Privacy and Ethics Knowledge Exam	Written exam	25%	75% (38 of 50 points)	A 50-question closed-book exam covering privacy law (HIPAA, FERPA, COPPA, CCPA/CPRA, GDPR), ethical principles, data classification concepts, de-identification theory, fairness metric definitions, and breach-response obligations; questions include multiple choice, matching, and short-answer items mapped to Google Data Analytics Certificate (responsible data practices), CompTIA Data+ (data governance and compliance), and IBM Data Science Professional (ethics and privacy) exam domains. Standard met · Safety · Time · Quality/finish · Documentation
De-identification and Bias Mitigation Skills Demonstration	Skills demonstration	45%	Instructor checklist: all required techniques correctly executed and all three fairness metrics within acceptable range; 75% on a 24-point rubric	Students receive a previously unseen synthetic dataset and, within a two-hour supervised session, must apply a complete de-identification pipeline in Python (identifier removal, generalization, k-anonymity verification), calculate demographic parity and equalized odds for a provided model output, and document all steps in a structured report; this demonstration maps to IBM Data Science Professional and CompTIA Data+ applied-skills competency areas. Standard met · Safety · Time · Quality/finish · Documentation
Ethics Audit Lab Log	Log	15%	All nine lesson lab log entries submitted; average entry score 75% or higher on the provided 10-point entry rubric	Students maintain a running lab log throughout the course, recording objectives, methods, results, and reflective interpretations for each lesson's hands-on activity; entries are reviewed at the end of Lesson 5 (formative) and at the end of the course (summative) to confirm accurate documentation of techniques, honest recording of errors and corrections, and progressive development of ethical reasoning skills. Standard met · Safety · Time · Quality/finish · Documentation
Workplace Data Ethics Safety Check	Safety audit	15%	All five mandatory items rated Satisfactory; any Unsatisfactory item must be remediated within one week and re-evaluated	An instructor-administered oral and scenario-based safety check evaluating five critical professional behaviors: correctly identifying when a dataset requires legal review before use, recognizing a reportable data breach and stating the correct first response, demonstrating proper access-control settings in a cloud storage tool, identifying a biased model output and naming the appropriate escalation path, and articulating the organization's duty to affected data subjects; this check aligns with the professional responsibility domains of all four target credentials and mirrors real employer onboarding compliance verifications. Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-11 Trade course

Capstone with Real City/Urbanicity Data

102 hr · ~~$1,225~~ COMPLIMENTARY

Students execute a complete, end-to-end data analytics project using publicly available municipal or regional datasets, moving from raw data acquisition through cleaning, analysis, visualization, and stakeholder-ready reporting. The course mirrors professional practice by requiring students to scope a real urban question, apply the full technical stack built across prior courses, and defend findings before a panel. Lessons map to Google Data Analytics Certificate competencies, CompTIA Data+ exam domains, Microsoft PL-300 exam objectives, and IBM Data Science Professional Certificate skill areas wherever applicable.

Outcomes

Acquire, assess, and document a real city or regional open dataset of at least 50,000 records, applying data-quality standards consistent with CompTIA Data+ Domain 1 (Data Concepts and Environments) requirements.
Formulate a clearly scoped analytical question tied to an urbanicity theme (e.g., transit equity, housing affordability, public-health disparity) and produce a written project charter with stakeholder personas and success metrics.
Clean, join, and transform multi-source city data using Python or R and SQL/PostgreSQL, producing a reproducible data-preparation pipeline with a documented audit trail aligned with Google Data Analytics Certificate process standards.
Build a spatial or statistical analysis that answers the project question, including at least one machine-learning model or advanced statistical technique, and evaluate model or analysis quality using appropriate metrics.
Deliver an interactive Power BI dashboard and a written technical report that communicate findings to both technical and non-technical audiences, satisfying Microsoft PL-300 report-design and data-modeling objectives.
Present and defend the completed project before a panel of instructors and one external reviewer, demonstrating professional communication, ethical data handling per course 10 principles, and the ability to respond to critical questions.

Course text

How the course runs. 9 blocks: Urban Data Landscape: Sources, Civic Open-Data Portals, and Project Scoping; Data Acquisition and Metadata Documentation; Exploratory Data Analysis on Urban Datasets; Data Cleaning and Multi-Source Integration Pipeline; Spatial Analysis and Mapping Urban Patterns; Statistical Analysis or Machine Learning Model for the Urban Question; Power BI Dashboard: City Data Storytelling; Technical Report Writing and Project Portfolio Assembly; Project Defense Preparation and Final Presentation.

What competent looks like. Acquire, assess, and document a real city or regional open dataset of at least 50,000 records, applying data-quality standards consistent with CompTIA Data+ Domain 1 (Data Concepts and Environments) requirements. Formulate a clearly scoped analytical question tied to an urbanicity theme (e.g., transit equity, housing affordability, public-health disparity) and produce a written project charter with stakeholder personas and success metrics. Clean, join, and transform multi-source city data using Python or R and SQL/PostgreSQL, producing a reproducible data-preparation pipeline with a documented audit trail aligned with Google Data Analytics Certificate process standards. Build a spatial or statistical analysis that answers the project question, including at least one machine-learning model or advanced statistical technique, and evaluate model or analysis quality using appropriate metrics. Deliver an interactive Power BI dashboard and a written technical report that communicate findings to both technical and non-technical audiences, satisfying Microsoft PL-300 report-design and data-modeling objectives. Present and defend the completed project before a panel of instructors and one external reviewer, demonstrating professional communication, ethical data handling per course 10 principles, and the ability to respond to critical questions.

Lessons · 9 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Urban Data Landscape: Sources, Civic Open-Data Portals, and Project Scoping	10	theory	Students identify at least three credible municipal open-data sources and write a one-page project charter that defines a focused urban analytical question, target audience, and measurable success criteria.	Guided tour of open-data portals (data.gov, city-specific portals such as NYC Open Data and Chicago Data Portal, Census Bureau TIGER/ACS, and regional transit authority feeds); students catalog five candidate datasets with metadata notes. Small-group discussion of urbanicity dimensions (density, transit access, income distribution, environmental exposure) to match each student's interest area to available data; instructor models a completed project charter using a prior cohort's anonymized example. Individual drafting of a project charter (problem statement, stakeholder persona, at least two research questions, proposed data sources, ethical considerations checklist drawn from Course 10); peer review using a structured rubric.	Laptop with browser, data.gov, Census Bureau American Community Survey explorer, city open-data portal accounts, project-charter template (instructor-provided Word/Google Doc), Course 10 ethics checklist, Google Data Analytics Certificate learner guide (Coursera).	Instructor reviews submitted project charter; pass requires a clearly stated analytical question, at least two identified datasets with source URLs and license notes, one identified ethical risk with a mitigation plan, and stakeholder persona — all four elements present = pass.
2	Data Acquisition and Metadata Documentation	10	lab	Students programmatically download or API-pull their chosen city datasets, inspect metadata and data dictionaries, and populate a standardized data-source log that records provenance, update frequency, and known limitations.	Live coding demo: instructor pulls a Chicago or similar city dataset via a Socrata open-data API using Python requests library, inspects column types, checks for missing fields, and writes results to a local PostgreSQL database; students replicate steps on their own chosen dataset. Students complete a data-source log spreadsheet (schema, row count, column definitions, date range, licensing, known caveats) for each dataset they plan to use, cross-referencing the official data dictionary PDF where available. Pair review: students swap data-source logs, attempt to locate the same dataset independently using only the documented URL and API parameters, and flag any gaps; discrepancies are corrected before submission.	Python 3 with pandas, requests, psycopg2; PostgreSQL 15; Jupyter Notebook; city open-data portal API keys; data-source log template (Excel/CSV); CompTIA Data+ official study guide (domain 1 — data acquisition and quality).	Instructor inspects data-source log and queries the student's PostgreSQL database; pass requires at least two datasets loaded without import errors, log contains all required fields for each source, and a peer reviewer was able to reproduce the download — all three criteria met = pass.
3	Exploratory Data Analysis on Urban Datasets	12	lab	Students conduct a structured exploratory data analysis (EDA) on their project datasets, producing summary statistics, distribution plots, and a written EDA report that identifies data-quality issues and initial analytical patterns.	Students run a standard EDA script template (value counts, null percentages, descriptive statistics, histograms, boxplots, correlation heatmap) adapted to their datasets in Jupyter Notebook; instructor circulates and prompts with targeted questions about unexpected distributions. Urban-context interpretation exercise: students annotate each plot with a sentence explaining what the pattern means for the city question (e.g., a right-skewed rent distribution in a neighborhood); annotations are shared in a class stand-up where two peers must ask a clarifying question. Students draft a two-page EDA report using a provided structure (data overview, key distributions, missing-data assessment, outlier discussion, revised research question if initial framing shifted); report is added to the project portfolio folder.	Python 3 with pandas, matplotlib, seaborn, scipy; Jupyter Notebook; EDA report template; Google Data Analytics Certificate — Ask and Prepare phases reference notes; CompTIA Data+ domain 2 (data mining) study cards.	EDA report scored on a four-criterion rubric (completeness of statistics, accuracy of plot interpretation, identification of at least two data-quality issues, revised research question if warranted); score of 75% or higher = pass.
4	Data Cleaning and Multi-Source Integration Pipeline	12	lab	Students build a reproducible Python or R data-cleaning and joining pipeline that resolves the data-quality issues identified in EDA and produces a single analysis-ready table, fully documented in a changelog.	Instructor demonstrates a multi-step cleaning pipeline for a two-source city dataset join (address standardization, FIPS code alignment, duplicate removal, missing-value imputation strategy with justification); students fork the notebook and adapt it to their own data. Students write a changelog Markdown file that records every transformation step (what changed, why, row counts before and after); a classmate must be able to rerun the notebook on the raw data and reproduce the final row count exactly. Students validate their clean table against three self-defined data-quality rules (e.g., no nulls in key join column, date range within project scope, numeric fields within plausible domain bounds) using assert statements or pandas .query() checks; failed assertions are corrected before submission.	Python 3 with pandas, numpy, pyjanitor; R with tidyverse (optional); PostgreSQL; Jupyter Notebook or R Markdown; Course 5 data-cleaning reference sheet; Google Data Analytics Certificate — Process phase notes.	Instructor reruns the cleaning notebook from raw data; pass requires zero assert-statement failures, changelog present with entries for every transformation, and final table row count matching the student's documented expected count — all three = pass.
5	Spatial Analysis and Mapping Urban Patterns	12	lab	Students perform at least one spatial join or geographic aggregation on their city data and produce a choropleth or point-density map that visually communicates a geographic pattern relevant to their research question.	Review of Course 9 GIS skills: instructor models joining census tract shapefile to city inspection data in GeoPandas, computing a per-capita rate by tract, and rendering a choropleth with a diverging color scheme and proper legend; students replicate with their own geometry layer. Students apply at least one spatial operation (buffer analysis, spatial join, or kernel density estimation) meaningful to their research question and document the CRS (coordinate reference system) used and any projection choices in their project notebook. Map critique exercise: students screenshot their map and post to a shared class board; two peers use a checklist (title, legend, north arrow or orientation note, data source credit, color accessibility for color-blind readers) to provide written feedback; students revise before submission.	Python 3 with geopandas, folium, matplotlib; QGIS 3 (optional); Census TIGER shapefiles; city-specific GIS portal layers; Course 9 spatial analysis notes; IBM Data Science Professional Certificate — data visualization module reference.	Instructor reviews submitted map and notebook; pass requires correct CRS documented, spatial operation applied without geometry errors, map passes at least four of five checklist items, and a one-paragraph narrative explaining the geographic pattern — all criteria met = pass.
6	Statistical Analysis or Machine Learning Model for the Urban Question	12	lab	Students apply at least one appropriate statistical test or supervised/unsupervised machine-learning model to their analysis-ready dataset and report evaluation metrics and practical significance in the context of their urban research question.	Students select and justify their analytical method (e.g., linear regression for predicting permit wait times, k-means clustering for neighborhood typology, chi-square test for transit-access disparity) using a decision-tree flowchart provided by the instructor; justification is written in the project notebook as a Markdown cell. Students implement the model or test in Python or R, compute evaluation metrics appropriate to the method (R-squared, RMSE, silhouette score, p-value with effect size), and interpret results in plain language tied to the city question. Instructor-led peer-review session: each student presents their method choice and one key metric in a two-minute stand-up; peers ask at least one question about assumptions or limitations; student adds a 'limitations' section to the notebook before final submission.	Python 3 with scikit-learn, statsmodels, scipy; R with caret or tidymodels (optional); Jupyter Notebook; IBM Data Science Professional Certificate — machine learning module; CompTIA Data+ domain 3 (data analysis) study guide.	Instructor reviews notebook for method justification, correct metric computation (verified by re-running the notebook), and a plain-language interpretation linked to the research question; all three present with no major computational errors = pass.
7	Power BI Dashboard: City Data Storytelling	12	lab	Students build a multi-page, interactive Power BI report connected to their analysis-ready dataset that enables a non-technical city stakeholder to explore key findings, applying PL-300 data-modeling and report-design best practices.	Instructor demonstrates importing a cleaned CSV into Power BI Desktop, creating a star-schema data model, writing at least two DAX measures (e.g., year-over-year change, per-capita rate), and designing a report page with slicers, a map visual, and a KPI card; students follow along on their own data. Students design a storyboard (paper or digital wireframe) for their two- to three-page report before building in Power BI; storyboard must identify the audience, one question answered per page, and the visual type chosen with a one-sentence justification. Students publish the completed Power BI report to Power BI Service (free workspace) and share the link with the instructor; a usability walk-through is conducted where the instructor plays the role of a city department manager and navigates the report without student guidance, noting any confusion points.	Power BI Desktop (free); Power BI Service free account; cleaned project dataset (CSV or PostgreSQL connection); Microsoft PL-300 exam study guide; DAX reference documentation (Microsoft Learn); storyboard template.	Instructor evaluates the published report against a rubric: functional data model (at least two tables related), at least two correct DAX measures, three or more interactive visuals, usability walk-through completed without critical navigation failures; score of 75% or higher = pass.
8	Technical Report Writing and Project Portfolio Assembly	10	practice	Students produce a complete written technical report and assemble a project portfolio folder containing all notebooks, cleaned data documentation, maps, and the Power BI report link, formatted for submission to a professional or academic reviewer.	Instructor shares a model technical report (anonymized from a prior cohort or a public city analytics report) and conducts a close-reading exercise highlighting structure: executive summary, methods, results, limitations, recommendations, and data-source appendix; students map their own work to each section. Students write a draft report of four to six pages (excluding appendices), targeting both a technical audience (methods section) and a lay audience (executive summary and recommendations); instructor holds individual fifteen-minute writing conferences to give targeted feedback on the executive summary and at least one results paragraph. Portfolio assembly checklist activity: students verify all required components are present and named according to the submission convention (project charter, EDA report, cleaning notebook with changelog, spatial map file, ML/stats notebook, Power BI link, technical report); a peer signs off the checklist before submission.	Google Docs or Microsoft Word; portfolio folder structure guide (instructor-provided); model technical report (PDF); Google Data Analytics Certificate — Share phase notes; plain-language writing guide (e.g., Plain Language.gov guidelines).	Instructor scores the draft report on a rubric: all six required sections present, executive summary readable by a non-technical reviewer (confirmed by a peer non-data-science student reading it), at least two actionable recommendations included, and portfolio checklist fully signed — all four criteria met = pass.
9	Project Defense Preparation and Final Presentation	12	practice	Students deliver a twelve-to-fifteen-minute structured oral defense of their completed capstone project before a panel that includes at least one external reviewer, demonstrating command of methods, findings, limitations, and responses to critical questions.	Defense structure workshop: instructor presents a defense rubric and models a ten-minute mock defense using a sample project, deliberately leaving two methodological weaknesses for students to identify; class debriefs on panel-question strategies (clarifying, defending, acknowledging limitations honestly). Each student conducts a full practice defense in a small group of three peers who use the official rubric to score the presentation and pose two challenging questions each; presenter responds and then receives written feedback; students revise slides and talking points. Final defense: students present to the panel (two instructors plus one external reviewer from a local government, consulting firm, or nonprofit); presentation is followed by ten minutes of Q&A; panel completes the official rubric independently and scores are averaged for the final grade.	Presentation software (PowerPoint or Google Slides); Power BI report (live); defense rubric (instructor-provided); printed one-page project summary handout for panel; completed portfolio folder submitted 48 hours before defense.	Panel average score on the defense rubric (content mastery, data-quality awareness, visualization clarity, communication quality, Q&A responsiveness, ethical handling of data); score of 75% or higher on rubric average AND all five portfolio components submitted on time = pass.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Project Charter and Methods Knowledge Exam	Written exam	25%	75% or higher (30 of 40 points)	A 40-question written exam covering urban open-data sourcing (CompTIA Data+ Domain 1), data-quality concepts, EDA principles (Google Data Analytics Certificate — Prepare/Process phases), spatial data fundamentals (IBM Data Science Professional), and Power BI data-modeling concepts (PL-300 objectives); questions include multiple choice, short answer, and one scenario-based data-quality case. Students must correctly identify data provenance requirements, appropriate statistical methods for at least two urban scenario prompts, and one DAX measure logic question. Standard met · Safety · Time · Quality/finish · Documentation
Live Dashboard and Analysis Skills Demonstration	Skills demonstration	45%	75% or higher on a 20-point rubric; all four rubric dimensions must score at least 2 of 5	Student shares screen and walks an evaluator through their completed Power BI report and one Jupyter Notebook analytical finding in twenty minutes, explaining every DAX measure, the spatial join logic, and the ML or statistical result; the evaluator may ask the student to filter the dashboard live, modify one DAX measure, or re-explain a chart interpretation. Rubric dimensions: data-model correctness, DAX accuracy, visualization design, and oral technical explanation. Standard met · Safety · Time · Quality/finish · Documentation
Project Portfolio Lab Log	Log	15%	All eight required components present and each meeting its individual lesson pass standard; overall portfolio scored at 75% or higher on completeness and reproducibility rubric	The complete project portfolio — project charter, data-source log, EDA report, cleaning notebook with changelog, spatial map with CRS documentation, ML/statistics notebook with evaluation metrics, Power BI report link, and final technical report — is evaluated by the instructor for reproducibility (notebooks rerun without errors), documentation completeness, and professional formatting. Missing components or notebooks that fail to rerun automatically result in a resubmission requirement before a passing grade is recorded. Standard met · Safety · Time · Quality/finish · Documentation
Ethical Data Handling and Professional Conduct Safety Check	Safety audit	15%	Pass/Fail — all five items must be marked Pass; any single Fail triggers a mandatory remediation conference and recheck before the final defense grade is recorded	A structured review conducted by the instructor against five non-negotiable standards derived from Course 10 (Ethics and Privacy): (1) no personally identifiable information exposed in any shared file or published dashboard, (2) all data sources cited with correct licenses and no prohibited reuse, (3) technical report includes a limitations and potential-bias section, (4) project charter ethical-risk mitigation plan was followed as documented, and (5) presentation does not make causal claims unsupported by the analysis design. This check mirrors professional ethics obligations applicable across all four credential areas (Google Data Analytics Certificate, CompTIA Data+, IBM Data Science Professional, and Microsoft PL-300). Standard met · Safety · Time · Quality/finish · Documentation

TEC-DATA85-12 Capstone

Capstone Project: End-to-End Data Science & Analytics Build

216 hr · ~~$2,160~~ COMPLIMENTARY

Students design, execute, and defend a complete data science project from raw data acquisition through cleaned datasets, exploratory analysis, machine learning model, interactive dashboard, and written report—mirroring the full professional workflow. The capstone integrates every prior course skill and is evaluated against industry rubrics aligned to the Google Data Analytics Certificate, CompTIA Data+, Microsoft PL-300, and IBM Data Science Professional credential competency areas. Students present findings to a panel of instructors and an industry reviewer, simulating a real workplace project delivery.

Outcomes

Formulate a testable analytical question, acquire appropriate public or partner datasets, and document a complete data management plan including privacy and ethical risk assessment.
Clean, transform, and validate a multi-source dataset in Python or R and SQL, producing a reproducible data pipeline with version-controlled code and a written data dictionary.
Build, evaluate, and interpret at least one supervised or unsupervised machine learning model, reporting performance metrics appropriate to the business question.
Construct a polished, audience-appropriate interactive dashboard in Power BI that communicates key findings through correctly labeled visualizations and executive summary text.
Produce a professional project report in standard technical writing format and deliver a 20-minute oral defense with Q&A before an instructor and industry-reviewer panel, achieving a passing score on all rubric dimensions.
Identify and apply relevant ethical, privacy, and data-governance principles throughout the project, citing specific decisions made to protect data subjects and ensure analytical integrity.

Course text

How the course runs. 4 blocks: Project Scoping, Data Acquisition, and Ethics Review; Data Pipeline: Cleaning, Transformation, and Exploratory Analysis; Modeling, Dashboard Build, and Report Drafting; Project Defense, Revision, and Final Submission.

What competent looks like. Formulate a testable analytical question, acquire appropriate public or partner datasets, and document a complete data management plan including privacy and ethical risk assessment. Clean, transform, and validate a multi-source dataset in Python or R and SQL, producing a reproducible data pipeline with version-controlled code and a written data dictionary. Build, evaluate, and interpret at least one supervised or unsupervised machine learning model, reporting performance metrics appropriate to the business question. Construct a polished, audience-appropriate interactive dashboard in Power BI that communicates key findings through correctly labeled visualizations and executive summary text. Produce a professional project report in standard technical writing format and deliver a 20-minute oral defense with Q&A before an instructor and industry-reviewer panel, achieving a passing score on all rubric dimensions. Identify and apply relevant ethical, privacy, and data-governance principles throughout the project, citing specific decisions made to protect data subjects and ensure analytical integrity.

Lessons · 4 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Project Scoping, Data Acquisition, and Ethics Review	48	lab	Students define a measurable analytical question, locate and acquire at least two appropriate datasets, and complete a written data management and ethics plan that passes peer and instructor review.	Each student drafts a one-page project brief stating the business or civic question, target audience, success criteria, and data sources; instructor provides written feedback using a structured brief rubric before the student proceeds. Students search public repositories (data.gov, Census Bureau, CDC, local open-data portals, Kaggle) and evaluate each candidate dataset against a checklist covering provenance, license, completeness, temporal coverage, and personally identifiable information (PII) risk, then select and download their final datasets with documented citations. Students complete a data management and ethics plan modeled on IRB-style documentation: they identify any sensitive attributes, state de-identification steps, describe storage and access controls, and sign a data-use acknowledgment; plans are reviewed in a structured peer critique session before instructor sign-off.	Computers with internet access; data.gov, Census Bureau, and local open-data portals; Google Sheets or Excel for preliminary inspection; course Ethics & Privacy module reference sheet; project brief template; data management plan template; CompTIA Data+ domain 1 (Data Concepts and Environments) study guide excerpt; IBM Data Science Professional Course 1 reading on CRISP-DM.	Instructor approves the project brief and data management plan using a 10-point rubric; students must score 8/10 or higher on both documents and have at least two datasets downloaded and citation-documented before advancing. PII risk section must receive a passing mark independently.
2	Data Pipeline: Cleaning, Transformation, and Exploratory Analysis	60	lab	Students build a documented, reproducible Python or R data pipeline that cleans and merges their raw datasets, produces a validated analysis-ready file, and generates a complete exploratory data analysis (EDA) report with descriptive statistics and at least six publication-quality charts.	Students write a step-by-step cleaning script in Python (pandas) or R (tidyverse) stored in a Git repository; the script handles missing values, outliers, data-type mismatches, and duplicate records using explicit, commented code; a classmate attempts to re-run the script on the same raw files and confirms reproducibility as part of a peer-code-review checklist. Students merge datasets using SQL joins executed inside Python (SQLAlchemy/psycopg2) or directly in PostgreSQL, producing a single analysis-ready table; they write a data dictionary spreadsheet defining every retained column, its data type, valid range, and any transformation applied—directly supporting CompTIA Data+ domain 2 (Data Mining) and Google Data Analytics Certificate data-cleaning competency areas. Students conduct EDA using descriptive statistics (central tendency, spread, skewness) and produce at least six visualizations (histogram, box plot, scatter plot, correlation heat map, bar chart, and one chart of their own choice) using Matplotlib, Seaborn, ggplot2, or equivalent; they write a one-paragraph interpretation beneath each chart in a Jupyter or R Markdown notebook that will become a chapter of the final report.	Python 3 with pandas, NumPy, Matplotlib, Seaborn, SQLAlchemy; or R with tidyverse, ggplot2, R Markdown; PostgreSQL; Git and GitHub (or GitLab); Jupyter Notebook or VS Code; peer code-review checklist; data dictionary template; CompTIA Data+ domain 2 reference; Google Data Analytics Certificate Process and Analyze phase competency list.	Instructor runs the student's cleaning script independently on the raw source files; script must execute without errors and produce a validated output file. Data dictionary must define 100% of retained columns. EDA notebook must contain at least six charts, each with a written interpretation; graded on a 20-point rubric—15/20 minimum to advance. Git repository must show meaningful commit history (minimum five commits).
3	Modeling, Dashboard Build, and Report Drafting	72	lab	Students train and evaluate at least one machine learning model appropriate to their question, build a fully interactive Power BI dashboard presenting key findings, and produce a complete draft project report that integrates all prior work.	Students select a modeling approach (classification, regression, clustering, or time-series forecasting) justified in a half-page model-selection memo; they split data into training and test sets, fit the model using scikit-learn or equivalent, compute at least two appropriate performance metrics (e.g., accuracy and F1 for classification; RMSE and R² for regression), and document hyperparameter choices and any cross-validation steps in their notebook—directly aligned to IBM Data Science Professional Course 6–9 (ML with Python) competency areas. Students build a Power BI report file (.pbix) containing at least four visuals (including one map visual if geographic data is present), a slicer for at least one dimension, a card showing a key KPI, and an executive-summary text box; they publish to Power BI Service and share a live link; the dashboard is evaluated against the Microsoft PL-300 domain areas covering data modeling, report design, and DAX measures. Students draft the complete project report following a standard technical report structure: executive summary, problem statement, data description and ethics review, methodology, results (EDA + model), dashboard description, limitations, recommendations, and references in APA format; draft is submitted for instructor feedback using a written report rubric before the defense.	Python with scikit-learn, statsmodels; Power BI Desktop (free) and Power BI Service account; DAX reference card; Microsoft PL-300 exam domain guide; IBM Data Science Professional Certificate ML competency checklist; project report template in .docx or Google Docs; APA citation guide; screen-recording software (OBS or equivalent) for dashboard walkthrough video.	Model evaluation section must include at least two correctly computed metrics with a written interpretation of what the numbers mean for the business question. Power BI dashboard must be live and shareable; evaluated on a 15-point PL-300-aligned rubric—minimum 11/15. Complete report draft must be submitted by the scheduled deadline; instructor must confirm all required sections are present before the defense is scheduled.
4	Project Defense, Revision, and Final Submission	36	practice	Students deliver a structured 20-minute oral defense of their project to an instructor-and-industry-reviewer panel, respond to 10 minutes of technical Q&A, incorporate feedback into final document revisions, and submit all deliverables in a complete, version-controlled project package.	Students rehearse their defense in a structured peer mock-defense session: each presenter receives a timer, a volunteer panel of two classmates, and a copy of the defense rubric; peers score the rehearsal and provide written feedback on clarity of findings, chart readability, model explanation, and handling of questions; students have 48 hours to revise slides and talking points before the real panel. Students deliver the formal 20-minute defense using slides and a live Power BI dashboard walkthrough before a panel that includes at least one instructor and one invited industry reviewer (employer, advisory board member, or alumni working in data); the panel scores the defense on the rubric and asks at least five technical questions drawn from the project's methodology, data decisions, model results, and ethical choices. Students incorporate all panel feedback into final revisions of the report and dashboard within one week of the defense; they compile the complete submission package—cleaned data files, Git repository link, .pbix file, final report PDF, and a completed project reflection memo (one page describing what they would do differently)—and upload to the program's learning management system (LMS) by the posted deadline.	Presentation slides (PowerPoint or Google Slides); Power BI Desktop and live Power BI Service link; defense rubric (shared with students at lesson 1 of capstone); peer mock-defense scoring sheet; industry reviewer evaluation form; LMS submission portal; Git repository; project reflection memo template.	Defense rubric has five scored dimensions (problem framing, data methodology, analytical rigor, communication clarity, Q&A responses), each scored 1–4; minimum passing score is 3 out of 4 on every dimension and a total score of 16/20. Final submission package must be complete and uploaded on time; missing any required file constitutes an incomplete and requires resubmission within 10 business days.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
End-to-End Capstone Project Package	Project	60%	Minimum 75% aggregate score across the project rubric dimensions: data pipeline (20 pts), machine learning model section (20 pts), Power BI dashboard (15 pts), written report (25 pts), and ethics/governance documentation (20 pts); no single dimension may score below 60%.	The complete deliverable set—reproducible Python or R pipeline in Git, validated dataset and data dictionary, Jupyter or R Markdown EDA notebook, trained model with evaluation metrics, live Power BI dashboard, and final written report—is scored by the instructor against a 100-point rubric aligned to Google Data Analytics Certificate, CompTIA Data+, Microsoft PL-300, and IBM Data Science Professional competency domains. The project must demonstrate an unbroken, documented workflow from raw data to actionable recommendation. Meets specification · Within estimate · Workmanship · Safety · Documentation
Professional Portfolio Entry	Portfolio	20%	All five required portfolio components submitted and each rated 'Meets Standard' or above on the portfolio checklist; any component rated 'Does Not Meet Standard' must be revised and resubmitted within five business days.	Students assemble a portfolio entry suitable for job applications, consisting of: a public GitHub repository with a professional README, a shareable Power BI Service dashboard link, a PDF of the final report, a one-page project summary written for a non-technical audience, and an updated resume that lists the capstone project with a one-sentence description of impact. The portfolio entry is reviewed by the instructor and by a peer using the program's standardized portfolio checklist, ensuring it is clean, navigable, and free of identifying information about any data subjects. Completeness · Organization · Evidence quality
Oral Defense and Q&A Panel	Oral / panel	20%	Score of 3 or higher (out of 4) on every one of the five defense rubric dimensions AND a total panel score of 16/20 or higher; a score below 3 on any single dimension requires a targeted remediation meeting and a second defense of that dimension within 10 business days.	The 20-minute structured oral defense before an instructor and at least one industry reviewer assesses the student's ability to explain analytical decisions, interpret results accurately, discuss ethical trade-offs, and respond to technical questions without reference to notes on factual matters. The panel evaluates problem framing, data methodology, analytical rigor, communication clarity, and Q&A responses using a shared rubric published at the start of the capstone; scores from both panelists are averaged for the final record. Explains decisions · Answers technical questions · Professional communication

TEC-DATA85-13 Externship / clinical

Externship / Worksite Placement: Data Science & Analytics

324 hr · ~~$1,295~~ COMPLIMENTARY

Students complete 324 supervised hours at an approved employer site in a data science, analytics, business intelligence, or related data-intensive role, applying classroom skills to authentic workplace projects under the guidance of a qualified industry mentor. The externship bridges academic preparation and professional practice by requiring students to contribute to real data pipelines, dashboards, analyses, or machine-learning workflows while meeting professional workplace standards. Competence is evaluated through a detailed employer rubric, a reflective journal, and a final site-supervisor assessment.

Outcomes

Perform assigned data analytics or data science tasks—including data collection, cleaning, analysis, and visualization—at a professional standard acceptable to the host employer.
Communicate findings and project status clearly in written reports and verbal briefings appropriate for both technical and non-technical workplace audiences.
Apply data privacy, security, and ethical handling practices consistent with organizational policies and applicable regulations during all worksite activities.
Demonstrate professional workplace behaviors including punctuality, respectful collaboration, version-control discipline, and adherence to organizational IT and data-governance policies.
Reflect critically on the gap between classroom learning and industry practice, identifying at least three technical or professional skills targeted for continued development.
Produce a worksite portfolio artifact—such as a cleaned dataset, dashboard, analysis report, or model evaluation—that meets employer quality standards and can be presented to future employers.

Course text

How the course runs. 4 blocks: Externship Orientation, Workplace Safety, and Professional Onboarding; Active Project Work: Data Collection, Cleaning, Analysis, and Visualization; Professional Communication, Collaboration, and Reflective Practice; Final Deliverable, Supervisor Evaluation, and Externship Debrief.

What competent looks like. Perform assigned data analytics or data science tasks—including data collection, cleaning, analysis, and visualization—at a professional standard acceptable to the host employer. Communicate findings and project status clearly in written reports and verbal briefings appropriate for both technical and non-technical workplace audiences. Apply data privacy, security, and ethical handling practices consistent with organizational policies and applicable regulations during all worksite activities. Demonstrate professional workplace behaviors including punctuality, respectful collaboration, version-control discipline, and adherence to organizational IT and data-governance policies. Reflect critically on the gap between classroom learning and industry practice, identifying at least three technical or professional skills targeted for continued development. Produce a worksite portfolio artifact—such as a cleaned dataset, dashboard, analysis report, or model evaluation—that meets employer quality standards and can be presented to future employers.

Lessons · 4 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Externship Orientation, Workplace Safety, and Professional Onboarding	36	field	Students complete employer onboarding, review site-specific safety and IT security policies, establish a learning agreement with their supervisor, and set measurable goals for the full placement.	Complete employer HR and IT onboarding: sign data-handling and confidentiality agreements, set up workstation access, and review the organization's acceptable-use and data-governance policies; document each step in the externship journal. Participate in a workplace safety walkthrough with the site supervisor, noting ergonomic workstation setup, emergency exit routes, incident-reporting procedures, and any industry-specific hazards (e.g., server-room access protocols, electrical safety near data-center equipment); record findings in a site-safety checklist submitted to the program coordinator. Draft a Supervised Learning Agreement with the site supervisor that specifies at least four project tasks, weekly check-in schedule, deliverable milestones tied to weeks 4, 8, and 12 of the placement, and the competencies from the program curriculum the student will demonstrate; obtain supervisor and coordinator signatures before week two begins.	Externship Learning Agreement template (program-issued), Site Safety Checklist form, externship journal (digital or paper), employer onboarding materials, OSHA 10 card (already earned in Course 1), organization's data-governance and acceptable-use policy documents.	Signed Learning Agreement with measurable goals on file with coordinator; completed Site Safety Checklist with supervisor initials; externship journal entry for each onboarding day; pass = all three documents received and approved by program coordinator before the end of orientation week.
2	Active Project Work: Data Collection, Cleaning, Analysis, and Visualization	200	lab	Students execute the project tasks defined in the Learning Agreement—spanning data ingestion, cleaning, exploratory analysis, and visual output—producing employer-reviewed deliverables that meet professional quality standards.	Carry out daily assigned analytics or data science work (e.g., writing SQL queries against production or staging databases, cleaning messy CSV or API-sourced datasets in Python or R, building or maintaining Power BI or Tableau dashboards, running descriptive or predictive analyses) and commit all code and documentation to the employer's version-control system or shared workspace at the end of each work session. Attend and contribute to at least four team meetings, stand-ups, or sprint reviews during the placement; prepare a brief written status update before each meeting and request feedback on at least one piece of work per meeting, recording the feedback and any action items in the externship journal. Complete one mid-placement portfolio artifact (e.g., a fully documented cleaned dataset with a data-quality report, a functional dashboard with a written user guide, or an analysis memo with visualizations and recommendations) and present it to the site supervisor for a formal mid-point review at approximately the 160-hour mark; revise the artifact based on supervisor feedback and resubmit within one week.	Employer-provisioned hardware and software (SQL client, Python/R environment, Power BI or Tableau, version-control system); externship journal; mid-point deliverable template (program-issued); CompTIA Data+ exam objectives (Da0-001 domain list) and Google Data Analytics and IBM Data Science Professional certificate competency checklists used as self-assessment guides during journal reflections.	Supervisor rates mid-point deliverable on the program's Employer Quality Rubric (five criteria: accuracy, documentation, visualization clarity, professional communication, adherence to data-privacy policy); pass = score of 3 out of 5 or higher on every criterion; journal entries present for every worksite day with a reflection of at least three sentences.
3	Professional Communication, Collaboration, and Reflective Practice	48	field	Students practice workplace communication skills—written reporting, data storytelling in meetings, and cross-functional collaboration—and use structured weekly journal reflections to connect worksite experiences to program competencies and target credential exam domains.	Produce a brief written analysis memo (one to two pages) for a non-technical stakeholder at the host site, translating a finding from the student's ongoing project into plain language with at least one supporting visualization; submit the memo to the supervisor for review, apply edits, and file the revised memo in the externship portfolio. Conduct a structured weekly self-assessment using the credential competency checklists (Google Data Analytics, CompTIA Data+, Microsoft PL-300 power-user skills, IBM Data Science Professional domains) to identify which skills were exercised that week and which gaps the Exam Prep course (Course 14) should address; record findings in the journal and share a summary with the program coordinator during the biweekly check-in call. Shadow or collaborate with at least two colleagues in different roles (e.g., a database administrator, a business analyst, a project manager) for a minimum of four hours each; afterward, write a one-page comparison describing each role's data responsibilities, tools used, and how the roles interact—connecting observations to at least one credential exam domain or program course.	Externship journal, employer communication style guide (if available), credential competency checklists (program-issued summary of Google Data Analytics, CompTIA Data+, Microsoft PL-300, and IBM Data Science Professional exam domains), biweekly check-in call agenda template, memo template.	Supervisor confirms student communication meets workplace standards (via Employer Quality Rubric communication criterion); weekly journal self-assessments present and substantive; role-comparison memo submitted; pass = supervisor communication rating of 3/5 or higher and all weekly journal entries complete and on time.
4	Final Deliverable, Supervisor Evaluation, and Externship Debrief	40	field	Students present a polished final worksite portfolio artifact to their supervisor, receive a formal employer evaluation, and participate in a program debrief that synthesizes externship learning and prepares them for Exam Prep (Course 14).	Finalize and present the capstone worksite artifact (building on the mid-point deliverable or a new completed project task) to the site supervisor and, if possible, to a small team audience; the presentation must include the business question addressed, the data and methods used, key findings with at least two visualizations, limitations, and recommendations—targeting a 10-to-15-minute delivery with five minutes of Q&A. Sit for a formal End-of-Placement Supervisor Evaluation using the program's structured Employer Evaluation Form (covering technical skill, data-quality standards, professionalism, communication, and workplace safety behaviors); review the completed form together with the supervisor in a closing feedback meeting and record three specific takeaways in the journal. Attend a program-facilitated externship debrief session (in-person or virtual) with other students and the program coordinator; present a five-minute summary of the placement experience, describe the final artifact, state the three most important skills practiced, and identify two competency gaps that will be prioritized in Exam Prep; submit the complete externship portfolio (journal, deliverables, supervisor evaluation form) to the program coordinator.	Final presentation slides or report (student-produced), Employer Evaluation Form (program-issued, five-domain rubric), complete externship journal, full portfolio of worksite artifacts, program coordinator debrief agenda, credential domain gap-analysis worksheet for hand-off to Course 14.	Employer Evaluation Form score of 3/5 or higher on all five domains; final artifact rated acceptable or above by supervisor; externship portfolio (journal plus artifacts) submitted and complete; debrief participation confirmed by coordinator; pass = all four conditions met; any domain rated below 3 requires a written remediation plan approved by the coordinator before Course 14 begins.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Employer Skills Demonstration Evaluation	Skills demonstration	70%	Score of 3 out of 5 or higher on every domain of the Employer Evaluation Form (technical skill, data-quality standards, professionalism, communication, and workplace safety behaviors), as rated by the site supervisor at the end of the placement.	The site supervisor completes the program's structured five-domain Employer Evaluation Form at the conclusion of the placement, rating the student's real-world performance on technical data tasks, adherence to data-quality and privacy standards, professional conduct, communication effectiveness, and workplace safety behaviors observed throughout the externship. Any domain rated below 3 triggers a remediation conference with the student, site supervisor, and program coordinator before the student may advance to Course 14. Competency · Safety · Attendance · Conduct · Initiative
Externship Portfolio Log	Log	30%	All required journal entries present (minimum one substantive entry per worksite day), at least two portfolio artifacts (mid-point and final) included and rated acceptable by the supervisor, and the credential gap-analysis worksheet completed; coordinator review confirms completeness.	The externship portfolio log is a compiled submission of the student's daily reflective journal, the signed Learning Agreement, the site-safety checklist, both employer-reviewed worksite artifacts, weekly credential self-assessments, the role-comparison memo, the analyst memo produced for a stakeholder, and the completed Employer Evaluation Form. The portfolio serves as documentary evidence that the full 324 hours were supervised, productive, and connected to program competencies and target credential exam domains. Complete · Verified

TEC-DATA85-14 Exam prep

Certification Exam Preparation: Google Data Analytics, PL-300, IBM Data Science, and CompTIA Data+

90 hr · ~~$900~~ COMPLIMENTARY

This course systematically reviews every exam domain covered by the Google Data Analytics Professional Certificate, Microsoft PL-300 (Power BI), IBM Data Science Professional Certificate, and CompTIA Data+ certification, using timed practice questions, targeted concept drills, and full-length mock exams. Learners identify personal knowledge gaps through diagnostic testing, then close those gaps through structured review sessions mapped directly to official exam objectives. The course culminates in full mock exams simulating real testing conditions, preparing learners to sit for all four credentials with confidence.

Outcomes

Score at or above the recognized passing threshold on a full-length mock exam for each of the four target credentials: Google Data Analytics, Microsoft PL-300, IBM Data Science Professional, and CompTIA Data+.
Correctly explain and apply the domain-specific vocabulary, frameworks, and processes tested on each credential exam, including data cleaning workflows, statistical concepts, machine learning fundamentals, and Power BI data modeling.
Use diagnostic practice-test results to generate a personal study plan that prioritizes weak domains and tracks improvement over repeated attempts.
Demonstrate exam-day readiness by completing timed, full-length practice exams without reference materials and managing time across all question types.
Interpret and respond to scenario-based questions that require integrating knowledge from multiple program courses, such as combining SQL querying, visualization best practices, and data ethics principles in a single item.
Accurately recall credential-specific policies, including what each exam tests, the format of each assessment, and the types of tasks or tools each credential validates.

Course text

How the course runs. 4 blocks: Diagnostic Assessment and Personalized Study Planning; Domain-by-Domain Targeted Review: Google Data Analytics and CompTIA Data+; Domain-by-Domain Targeted Review: Microsoft PL-300 (Power BI) and IBM Data Science Professional; Full Mock Exams Under Timed, Proctored Conditions.

What competent looks like. Score at or above the recognized passing threshold on a full-length mock exam for each of the four target credentials: Google Data Analytics, Microsoft PL-300, IBM Data Science Professional, and CompTIA Data+. Correctly explain and apply the domain-specific vocabulary, frameworks, and processes tested on each credential exam, including data cleaning workflows, statistical concepts, machine learning fundamentals, and Power BI data modeling. Use diagnostic practice-test results to generate a personal study plan that prioritizes weak domains and tracks improvement over repeated attempts. Demonstrate exam-day readiness by completing timed, full-length practice exams without reference materials and managing time across all question types. Interpret and respond to scenario-based questions that require integrating knowledge from multiple program courses, such as combining SQL querying, visualization best practices, and data ethics principles in a single item. Accurately recall credential-specific policies, including what each exam tests, the format of each assessment, and the types of tasks or tools each credential validates.

Lessons · 4 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Diagnostic Assessment and Personalized Study Planning	12	practice	Given a set of shortened diagnostic practice tests covering all four credential domains, the learner will score each domain, identify the two weakest areas per exam, and produce a written personal study plan with specific goals and review resources.	Complete a 40-question timed diagnostic practice test for each of the four credentials (Google Data Analytics, PL-300, IBM Data Science Professional, CompTIA Data+), using published sample questions and official exam guides from each issuing body, then score each test by domain. Create a gap analysis matrix: list all official exam domains for each credential in a spreadsheet, enter diagnostic scores per domain, apply conditional formatting to flag any domain below 70 percent, and rank domains by priority for review. Write a one-page personal study plan for each credential that states specific score targets, lists the lessons or resources that address each flagged domain, and sets a daily study schedule for the remaining weeks of the course; share the plan with the instructor for written feedback.	Official exam guides and published sample questions from Google, Microsoft (PL-300 exam page), IBM (Coursera IBM Data Science Professional Certificate documentation), and CompTIA (Data+ Exam Objectives, current version); spreadsheet software (Excel or Google Sheets); course notes and textbooks from Courses 2–13; timer or online proctoring simulator.	Instructor reviews the gap analysis matrix and personal study plan for each of the four credentials; learner must correctly identify at least two specific domains below 70 percent per exam and list at least two concrete remediation steps per flagged domain — pass requires a complete, accurate plan for all four credentials submitted and accepted.
2	Domain-by-Domain Targeted Review: Google Data Analytics and CompTIA Data+	24	theory	For each domain listed in the Google Data Analytics Professional Certificate objectives and the CompTIA Data+ exam objectives, the learner will answer domain-focused practice question sets and achieve at least 75 percent accuracy per domain before moving to the next.	Work through the Google Data Analytics domain areas — including data cleaning and transformation, analysis with spreadsheets and SQL, data visualization principles, and sharing insights with stakeholders — by completing 20-question practice sets per domain using Coursera's Google Data Analytics quiz banks and third-party Quizlet decks aligned to official objectives; retake any set scoring below 75 percent after targeted reading review. Work through the CompTIA Data+ exam domains — including data concepts and environments, data mining, data analysis, visualization, and data governance, quality, and controls — by completing 20-question practice sets per domain using CompTIA's official study guide (current edition) and CertMaster Learn practice questions; for each wrong answer, write a one-sentence correction explaining the right concept in plain language. Conduct two 30-minute peer review sessions in pairs: each learner selects five scenario-based questions from either credential's domain set, reads them aloud, and the pair discusses the reasoning path before answering; debrief focuses on eliminating common wrong-answer patterns such as confusing correlation with causation or misidentifying visualization types.	CompTIA Data+ Exam Objectives (current version, free PDF from CompTIA website); CompTIA Data+ Study Guide (current edition); Google Data Analytics Professional Certificate course materials on Coursera; third-party practice question platforms (Quizlet, Udemy practice tests aligned to each objective); course notes from Courses 2, 5, 6, and 10; whiteboard or shared online document for peer discussion.	Instructor reviews the per-domain practice-set score logs for both credentials; learner must reach at least 75 percent on every domain set for both Google Data Analytics and CompTIA Data+ before the lesson is marked complete — any domain still below 75 percent requires one additional targeted review cycle with instructor guidance before progression.
3	Domain-by-Domain Targeted Review: Microsoft PL-300 (Power BI) and IBM Data Science Professional	24	lab	For each domain listed in the Microsoft PL-300 exam skills measured document and the IBM Data Science Professional Certificate objectives, the learner will complete domain-focused practice question sets and hands-on skill tasks, achieving at least 75 percent accuracy per domain.	Work through the Microsoft PL-300 exam skill areas — including preparing data in Power BI, modeling data, visualizing and analyzing data, and deploying and maintaining assets — by completing 20-question practice sets per skill area using Microsoft Learn's official PL-300 practice assessment and third-party practice banks; for modeling and DAX questions, open Power BI Desktop, reproduce the scenario in a live dataset, and verify the correct measure or relationship before marking the answer. Work through the IBM Data Science Professional Certificate domain areas — including data science methodology, Python for data science, data visualization, machine learning with Scikit-learn, and applied data science capstone competencies — by completing 20-question practice sets using Coursera quiz banks from the IBM program and supplementary flashcard decks; for any machine learning question answered incorrectly, open a Jupyter Notebook and implement a minimal working example of the algorithm or evaluation metric in question to reinforce conceptual understanding with code. Complete a 90-minute integrated lab: given a raw CSV dataset, load it into both Power BI Desktop and a Jupyter Notebook, build a clean data model and one DAX measure in Power BI, then build a logistic regression model and produce a confusion matrix in Python — then answer 10 examiner-style questions drawn from PL-300 and IBM domains that reference specific steps taken in the lab, simulating the applied and scenario-based item types used in both credentials.	Microsoft PL-300 Exam Skills Measured document (current version, free from Microsoft Learn); Microsoft Learn PL-300 practice assessment; Power BI Desktop (free download); IBM Data Science Professional Certificate course materials on Coursera; Jupyter Notebook (Anaconda distribution); Scikit-learn documentation; sample CSV datasets from course 5 and course 8; timer.	Instructor reviews domain score logs and the integrated lab write-up; learner must reach at least 75 percent on every PL-300 skill area and every IBM domain set, and the integrated lab must include a functioning Power BI file and a Jupyter Notebook that executes without errors — pass requires all domains at threshold and a complete, working lab submission.
4	Full Mock Exams Under Timed, Proctored Conditions	30	practice	Under timed, closed-book conditions that simulate actual exam environments, the learner will complete a full-length mock exam for each of the four target credentials and score at or above 75 percent on each, then complete a structured post-exam debrief identifying remaining weak items.	Sit four full-length, timed mock exams on separate days in the following order: CompTIA Data+ (90 questions, 90 minutes, closed book, no notes), Google Data Analytics domain review mock (60 scenario-based questions, 90 minutes), IBM Data Science Professional comprehensive quiz (60 questions, 90 minutes), and Microsoft PL-300 full practice assessment via Microsoft Learn (60 questions, 60 minutes); use a physical or virtual timer, silence all non-exam applications, and do not access course notes or the internet during each exam window. After each mock exam, complete a structured debrief worksheet: list every question answered incorrectly, write the correct answer and a one-sentence rationale, identify which exam domain the question belongs to, and rate personal confidence in that domain from 1–5; submit the worksheet to the instructor within 24 hours of each mock sitting. In the final session, participate in a 60-minute whole-class debrief led by the instructor: the instructor presents the five most commonly missed item types across all four credentials as shown by aggregated debrief worksheet data, works through the correct reasoning for each item type using a think-aloud method, and each learner writes a final one-paragraph reflection on their readiness and any last-day review priority before scheduling their actual credential exams.	Microsoft Learn PL-300 practice assessment (free); CompTIA CertMaster Practice or equivalent full-length Data+ practice exam; Coursera quiz banks for Google Data Analytics and IBM Data Science Professional; printed or digital debrief worksheet template; timer; scratch paper for calculations (permitted in some exams); current candidate handbook for each credential to confirm calculator and scratch paper policies.	Instructor reviews all four mock exam score reports and four completed debrief worksheets; pass standard is a score of at least 75 percent on every full-length mock exam for all four credentials and a complete, accurate debrief worksheet for each sitting — learners who score below 75 percent on any single mock complete one additional focused review cycle and a retake mock before the course is marked complete.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Four-Credential Full Mock Exam Battery	Mock certification exam	100%	A score of at least 75 percent on each of the four full-length mock exams (Google Data Analytics, Microsoft PL-300, IBM Data Science Professional, and CompTIA Data+), plus a complete and accurate debrief worksheet submitted for each exam; learners who do not meet the threshold on any individual mock must complete a targeted remediation cycle and pass a retake mock for that credential.	Each learner sits a full-length, timed, closed-book mock exam for all four target credentials under conditions that closely simulate the actual testing environment, including time limits consistent with each credential's published format and no access to notes, course materials, or the internet during the exam window. After each sitting, the learner submits a structured debrief worksheet identifying every incorrect item, the correct reasoning, and the associated exam domain, demonstrating both performance readiness and the self-assessment skills needed to close any remaining gaps before sitting the official credential exams. Score · Time management

Program completion

External credential: CompTIA Data+; Google Data Analytics Cert; IBM Data Science Professional; Microsoft PL-300 (Power BI)

Students sit four industry certification exams: the Google Data Analytics Professional Certificate (administered by Google via Coursera), the Microsoft Power BI Data Analyst exam PL-300 (administered by Microsoft), the IBM Data Science Professional Certificate (administered by IBM via Coursera), and the CompTIA Data+ exam (administered by CompTIA at authorized testing centers). Pass standard: Credential issued by the body.

Back to Data Science & Analytics · How the school gets authority to award these credentials