Grade 13 · a vocational technology learning center, by urbanicity

newSchoolWorks.com › VoTechWorks › Technology & Design › Web & Software Development › 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.

Web & Software Development

10 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,800~~ COMPLIMENTARYprogram tuition

10courses

91lessons

1,800hours

35assessments

Development progressPlanCourses, lessons and assessments written for this tradeLessons91 of 91 lesson pages writtenPractice728 practice questionsResources115 reference entries (study list)Review0 lesson pages reviewed by a licensed professional

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

TEC-WEB46-01 Universal core

Universal Core: Safety, Digital Foundations, Math & Career Readiness for Web & Software Development

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

This foundational course equips adult learners entering web and software development with the workplace safety knowledge, technical mathematics, professional communication skills, and career-readiness habits required to succeed in the program and the industry. Students complete OSHA 10-Hour General Industry training, basic first aid and CPR awareness, and develop the digital literacy and self-management practices expected by technology employers. All content is contextualized to real web development environments, tools, and professional norms.

Outcomes

Demonstrate awareness of OSHA 10-Hour General Industry hazard recognition principles and apply them to a physical and digital technology workspace.
Apply binary, hexadecimal, and Boolean arithmetic to solve problems typical of web and software development contexts.
Read and interpret technical documentation, developer style guides, and professional reference materials accurately.
Use core digital productivity tools—including file management, cloud storage, email, calendaring, and collaborative editors—at a professional entry level.
Produce and deliver professional written and oral communications appropriate to the technology workplace, including a resume, cover letter, and a brief technical presentation.
Identify the CompTIA ITF+, CompTIA Linux+, and PCEP Python credentials and connect their exam domains to skills developed across the full program.

Course text

How the course runs. 7 blocks: Workplace Safety for Technology Professionals: OSHA 10-Hour General Industry & Ergonomics; First Aid Awareness, CPR Basics & Emergency Procedures in Tech Environments; Technical Math for Web & Software Development: Number Systems, Boolean Logic & Measurement; Reading Technical Documentation & Developer References; Digital Productivity Tools: File Management, Cloud Collaboration & Professional Communication; Professional Communication: Writing, Presentation & Industry Vocabulary; Career Pathways & Credential Overview: ITF+, Linux+, PCEP Python & Industry Landscape.

What competent looks like. Demonstrate awareness of OSHA 10-Hour General Industry hazard recognition principles and apply them to a physical and digital technology workspace. Apply binary, hexadecimal, and Boolean arithmetic to solve problems typical of web and software development contexts. Read and interpret technical documentation, developer style guides, and professional reference materials accurately. Use core digital productivity tools—including file management, cloud storage, email, calendaring, and collaborative editors—at a professional entry level. Produce and deliver professional written and oral communications appropriate to the technology workplace, including a resume, cover letter, and a brief technical presentation. Identify the CompTIA ITF+, CompTIA Linux+, and PCEP Python credentials and connect their exam domains to skills developed across the full program.

Lessons · 7 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Workplace Safety for Technology Professionals: OSHA 10-Hour General Industry & Ergonomics	24	theory	Students will identify OSHA 10-Hour General Industry hazard categories, recognize electrical, ergonomic, and fire hazards common to technology workplaces, and describe the correct response to each.	Complete the OSHA 10-Hour General Industry online or instructor-led training modules, document completion, and discuss how each hazard category (electrical safety, walking/working surfaces, emergency action plans, fire protection) applies to a server room, coworking office, or remote home-office setup. Conduct a guided ergonomic self-assessment of a workstation using a published ergonomics checklist (such as OSHA's Computer Workstation eTool guidance), photograph their setup, annotate at least five risk factors, and propose corrective actions in a short written report. Participate in a tabletop scenario exercise: given a card describing a workplace incident (e.g., a power strip overload in a server closet, a slip hazard near a rack unit, a fire alarm during a deployment window), teams identify the hazard class, the correct OSHA response, and who is responsible for corrective action.	OSHA 10-Hour General Industry course materials (authorized provider), OSHA Computer Workstation eTool reference, OSHA poster 'Job Safety and Health: It's the Law', ergonomic checklist handout, incident scenario cards, student notebooks	Students score 70% or higher on the OSHA 10 final assessment to receive the OSHA 10-Hour card; separately submit an ergonomic report identifying at least five hazards with corrective actions rated Satisfactory by instructor.
2	First Aid Awareness, CPR Basics & Emergency Procedures in Tech Environments	8	demo	Students will describe the steps of Hands-Only CPR, demonstrate the use of an AED trainer, and state the correct emergency response procedures for the situations most likely in a technology workplace.	Watch a nationally recognized CPR/AED awareness video (e.g., American Heart Association Hands-Only CPR public resource) and practice the compression rate and depth on a manikin or cushion, with instructor feedback on form. Locate the AED, fire extinguisher, and emergency exits in the classroom or training facility, record their locations on a floor-plan sketch, and review the facility's emergency action plan document. Role-play a scenario in pairs: one student 'discovers' an unresponsive colleague at a workstation; the other talks through the chain of survival—call 911, begin Hands-Only CPR, send someone for the AED—and the class debriefs the correct sequence together.	CPR manikin or substitute cushion, AED trainer unit (non-live), American Heart Association Hands-Only CPR reference card, facility emergency action plan, floor-plan worksheet	Students correctly verbalize all steps of the Hands-Only CPR chain of survival and locate all emergency equipment during a walk-through check; instructor marks each student Pass or Needs Review on a two-item checklist.
3	Technical Math for Web & Software Development: Number Systems, Boolean Logic & Measurement	30	practice	Students will convert values between binary, decimal, and hexadecimal, apply Boolean operators to evaluate logical expressions, and calculate common web measurements such as pixel density, file size in bytes, and network bandwidth usage.	Complete a graded worksheet set covering binary-to-decimal and decimal-to-binary conversion (up to 16-bit values), hexadecimal color codes used in CSS (e.g., #FF5733 to RGB components), and byte/kilobyte/megabyte/gigabyte unit conversion; students check answers against an answer key and correct errors with annotation. Use a truth table template to evaluate AND, OR, NOT, and XOR expressions for inputs A and B, then connect the exercise to real code by reading a short JavaScript conditional snippet and mapping each condition to its Boolean result. Solve a set of applied 'story problems' drawn from the trade: calculate the storage needed for a web asset folder given file counts and average sizes, estimate page-load data usage for a mobile user on a metered connection, and determine the correct CSS viewport width breakpoints for three device categories using given screen specifications.	Number systems worksheet packet (instructor-prepared), truth table template, JavaScript snippet printout, calculator, graph paper, CompTIA ITF+ Study Guide (current edition) chapters on number systems and binary	Students achieve 75% or higher on the graded worksheet set; instructor reviews each story-problem solution for correct unit conversion and process shown.
4	Reading Technical Documentation & Developer References	20	theory	Students will locate, read, and accurately summarize information from technical documentation formats commonly used in web and software development, including API reference pages, man pages, README files, and style guides.	Given three print or PDF excerpts—one from the MDN Web Docs HTML element reference, one from a Python library README on GitHub (plain text version), and one abbreviated man page—students answer a set of comprehension questions that require them to locate a specific parameter, identify a required argument, and state a described limitation. Compare two competing documentation sources for the same topic (e.g., MDN versus W3Schools on the same CSS property) and write a one-paragraph evaluation noting which source is more precise, which is more readable, and how they would use each professionally. Annotate a one-page technical specification document (instructor-provided, based on a real open-source project CONTRIBUTING.md or similar) by highlighting: definitions, requirements language (must/should/may), version constraints, and examples; share annotations with a partner for peer comparison.	Printed excerpts from MDN Web Docs, Python library README (plain text), Linux man page, W3Schools printout, annotated specification template, highlighters, pens	Comprehension question set scored at 75% or higher; annotation exercise rated Satisfactory by instructor using a four-criteria rubric (definitions, requirements language, version constraints, examples each identified correctly).
5	Digital Productivity Tools: File Management, Cloud Collaboration & Professional Communication	24	lab	Students will organize a project file system using a professional naming convention, share and co-edit a document in a cloud productivity suite, and send a professionally formatted technical email with an attachment.	Create a local and cloud-mirrored folder structure for a hypothetical web project following a written naming convention guide (e.g., kebab-case folder names, versioned filenames, separation of assets/src/docs); instructor inspects the structure against a checklist of at least eight criteria. In pairs, open a shared cloud document (Google Docs or Microsoft 365, whichever the lab provides), simultaneously draft a short project plan outline with assigned sections, use the commenting and suggestion features to give each other feedback, and resolve all comments before final submission. Draft and send (to the instructor's address) a professional email requesting a code review appointment: subject line, greeting, one-paragraph context, specific ask, a correctly attached dummy file, and a professional sign-off; instructor evaluates against a rubric.	Lab computers with internet access, Google Workspace or Microsoft 365 accounts, cloud storage access, email client or webmail, naming convention guide handout, email rubric	File structure checklist passed at 8 of 8 criteria; cloud document completed with all comments resolved; email rated Satisfactory (all six rubric elements present and professional).
6	Professional Communication: Writing, Presentation & Industry Vocabulary	24	practice	Students will write a job-ready resume and cover letter targeted to an entry-level web developer posting, and deliver a three-minute technical presentation using correct industry terminology.	Analyze two sample resumes for entry-level web developers (one weak, one strong—instructor-provided), identify at least five differences using a comparison worksheet, then draft their own one-page resume using a clean template and a real or realistic job description as the target; peer review using a rubric covering formatting, action verbs, and quantified achievements. Write a three-paragraph cover letter tailored to the same job description, applying a provided professional writing checklist (clear opening, evidence paragraph, strong close); instructor provides written feedback before students revise and resubmit a final version. Prepare and deliver a three-minute 'tech talk' to the class on any topic covered so far in the course (e.g., binary number systems, an OSHA hazard category, a documentation tool); must include at least one visual aid (slide or whiteboard diagram) and use at least five domain-specific vocabulary terms correctly; peers complete a brief feedback form.	Sample resume pair (instructor-prepared), blank resume template, job description printout, cover letter checklist, presentation rubric, peer feedback form, projector or whiteboard, presentation software (PowerPoint, Google Slides, or equivalent)	Resume passes peer and instructor rubric at 80% of criteria; cover letter rated Satisfactory after one revision cycle; presentation meets all three elements of the rubric (time 2:30–3:30, five vocabulary terms used correctly, visual aid present) — marked Pass or Redo.
7	Career Pathways & Credential Overview: ITF+, Linux+, PCEP Python & Industry Landscape	18	theory	Students will describe the roles and responsibilities of at least four web and software development job titles, map the three program credentials (CompTIA ITF+, CompTIA Linux+, PCEP Python) to specific program courses and industry job functions, and state the general exam structure and exam-day procedures for each credential.	Research and compare four job titles (e.g., Front-End Developer, Back-End Developer, DevOps Engineer, Full-Stack Developer) using a structured template: typical duties, common tools, median salary range from a public source (BLS Occupational Outlook Handbook or similar), and which program credential is most relevant; present findings in a one-page profile sheet. Complete a credential mapping activity: given the official exam objectives for CompTIA ITF+, CompTIA Linux+, and PCEP Python (from CompTIA's and the Python Institute's publicly posted exam objectives documents), students draw lines connecting each exam domain to the program course where it is taught, then write one sentence explaining the connection for each credential. Participate in a guided Q&A panel discussion (instructor plays multiple roles or invites a guest via video) covering: how to register for each exam, general test-taking strategies for multiple-choice and performance-based questions, what to do if you do not pass the first time, and how to maintain a credential once earned; students record three action items for their own exam preparation plan.	BLS Occupational Outlook Handbook (online or printed excerpts), CompTIA ITF+ exam objectives (current version, publicly available PDF), CompTIA Linux+ exam objectives (current version), PCEP Python exam syllabus (Python Institute, current version), credential mapping worksheet, job profile template	Job profile sheet rated Satisfactory (all four fields completed for all four titles with a cited source); credential mapping worksheet checked for accuracy against the published objectives—at least 80% of domains correctly mapped; three exam action items recorded and submitted.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Safety & Technical Foundations Knowledge Exam	Written exam	25%	70% correct (35 of 50 items)	A 50-item multiple-choice and true/false exam covering OSHA 10-Hour General Industry hazard categories, first aid and CPR steps, binary and hexadecimal number systems, Boolean logic, and byte/bandwidth measurement conversions. Questions are drawn from lesson content and contextualized to technology workplaces to mirror the style of the CompTIA ITF+ exam. Accuracy · Safety · Communication · Professionalism
Technical Reading & Digital Tools Knowledge Exam	Written exam	25%	75% correct (30 of 40 items)	A 40-item exam combining multiple-choice comprehension questions drawn from a provided API reference excerpt and a man-page snippet, along with scenario-based questions on professional email etiquette, file-naming conventions, and cloud collaboration features. This assessment directly prepares students for the reading and tool-identification question types found on the CompTIA ITF+ exam. Accuracy · Safety · Communication · Professionalism
Career Readiness Portfolio Project	Project	25%	Satisfactory on all four required components (no Unsatisfactory ratings)	Students submit a complete career-readiness portfolio containing: (1) a finalized one-page resume, (2) a finalized cover letter addressed to a real or realistic job posting, (3) a credential pathway map connecting ITF+, Linux+, and PCEP Python domains to program courses, and (4) a one-page personal exam preparation plan with target dates for each credential exam. Each component is evaluated against its own rubric, and all four must reach Satisfactory for the project to pass. Accuracy · Safety · Communication · Professionalism
Oral Defense: Safety Scenario & Career Readiness	Oral / panel	25%	Pass on both evaluated dimensions (Demonstrate and Communicate), each rated at least Satisfactory	In a 10-minute one-on-one session with the instructor, the student responds to a randomly drawn workplace safety scenario (identifying the hazard, citing the relevant OSHA category, and describing the correct response) and then fields two questions about their credential pathway map and exam preparation plan. The instructor scores the student on two dimensions: accuracy of safety knowledge and clarity of professional communication, both rated on a three-point scale (Unsatisfactory / Satisfactory / Exceeds); both dimensions must reach Satisfactory to pass. Accuracy · Safety · Communication · Professionalism

TEC-WEB46-02 Trade course

HTML, CSS, and JavaScript for Web Development

171 hr · ~~$2,050~~ COMPLIMENTARY

Students build static and interactive web pages using HTML5, CSS3, and vanilla JavaScript, applying industry-standard structure, styling, and client-side scripting techniques. The course covers semantic markup, responsive layout with Flexbox and Grid, DOM manipulation, event handling, and browser developer tools. Lesson content maps to CompTIA ITF+ exam objectives covering software development concepts, web technologies, and basic programming logic.

Outcomes

Write well-formed, semantic HTML5 documents that pass W3C validation and meet basic WCAG 2.1 accessibility guidelines.
Apply CSS3 including Flexbox and CSS Grid to produce responsive layouts that adapt correctly to mobile, tablet, and desktop viewports.
Write JavaScript that selects DOM elements, handles user events, manipulates content dynamically, and performs basic form validation.
Use browser developer tools to inspect elements, debug CSS layout issues, and step through JavaScript errors in the console.
Organize a multi-page website project with a clean file and folder structure, consistent naming conventions, and commented code.
Explain core web development concepts — including how browsers parse HTML/CSS/JS, the client-server model, and HTTP request/response — as tested on the CompTIA ITF+ exam.

Course text

How the course runs. 12 blocks: How the Web Works: Clients, Servers, and Browsers; HTML5 Document Structure and Semantic Markup; HTML Text, Links, Images, Tables, and Forms; CSS Fundamentals: Selectors, the Box Model, and Cascade; CSS Layouts: Flexbox and CSS Grid; Responsive Web Design and Media Queries; JavaScript Fundamentals: Variables, Data Types, Operators, and Control Flow; JavaScript Functions, Arrays, and Objects; DOM Manipulation and Event Handling; Forms, Validation, and Fetch API Basics; Browser Developer Tools, Debugging, and Accessibility Auditing; Integrated Project: Multi-Page Responsive Website.

What competent looks like. Write well-formed, semantic HTML5 documents that pass W3C validation and meet basic WCAG 2.1 accessibility guidelines. Apply CSS3 including Flexbox and CSS Grid to produce responsive layouts that adapt correctly to mobile, tablet, and desktop viewports. Write JavaScript that selects DOM elements, handles user events, manipulates content dynamically, and performs basic form validation. Use browser developer tools to inspect elements, debug CSS layout issues, and step through JavaScript errors in the console. Organize a multi-page website project with a clean file and folder structure, consistent naming conventions, and commented code. Explain core web development concepts — including how browsers parse HTML/CSS/JS, the client-server model, and HTTP request/response — as tested on the CompTIA ITF+ exam.

Lessons · 12 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	How the Web Works: Clients, Servers, and Browsers	10	theory	Students explain the client-server model, the HTTP request/response cycle, and how a browser parses and renders HTML, CSS, and JavaScript.	Annotated diagram activity: students draw and label the full path of a browser request from URL entry to rendered page, identifying DNS, HTTP methods, status codes, and rendering steps. Guided reading from MDN Web Docs 'How the Web Works' series followed by a structured note-taking exercise using a provided graphic organizer. Whole-class discussion comparing static vs. dynamic websites using live examples; students categorize five real sites as static or dynamic with written justification.	MDN Web Docs (developer.mozilla.org), browser (Chrome or Firefox), whiteboard/projector, graphic organizer handout, CompTIA ITF+ Official Study Guide (CertMaster chapter on software and web concepts)	Exit-ticket quiz of 10 multiple-choice questions covering HTTP methods, status codes, rendering order, and client-server vocabulary; pass mark 70%.
2	HTML5 Document Structure and Semantic Markup	15	lab	Students create valid HTML5 documents using correct DOCTYPE, head metadata, and semantic structural elements including header, nav, main, section, article, aside, and footer.	Code-along lab: instructor live-codes a bare HTML5 skeleton; students replicate it from scratch on their own machines and annotate each tag's purpose in code comments. Semantic audit exercise: students are given a non-semantic HTML file built entirely with div and span tags and must refactor it using appropriate semantic elements, justifying each replacement in writing. W3C Markup Validation Service exercise: students submit their refactored file to validator.w3.org, screenshot the results, fix all errors, and document the corrections in a lab log entry.	VS Code with Live Server extension, Chrome browser, W3C Markup Validation Service (validator.w3.org), MDN HTML element reference, provided non-semantic starter file	Instructor reviews submitted HTML file: must pass W3C validation with zero errors, use at least six distinct semantic structural elements correctly, and include complete head metadata; pass mark 80% of rubric criteria met.
3	HTML Text, Links, Images, Tables, and Forms	14	lab	Students mark up text content, hyperlinks with relative and absolute paths, images with descriptive alt text, data tables with proper thead/tbody/th scope, and accessible HTML forms with labels and input types.	Guided lab: students build a multi-section HTML-only information page for a fictional business that includes headings, paragraphs, an ordered list, an unordered list, an external link, an internal anchor, and at least two images with meaningful alt text. Table construction drill: students convert a provided CSV dataset into a correctly structured HTML table with a caption, column headers using scope='col', and at least one row header using scope='row'. Form-building challenge: students independently construct a contact form with text, email, telephone, textarea, select, checkbox, and submit inputs — all with associated label elements — then test tab-order navigation using keyboard only.	VS Code, Live Server, MDN HTML forms guide, MDN table accessibility guide, WCAG 2.1 quick reference (w3.org/WAI), provided CSV dataset	Peer review using a shared rubric covering alt text presence, label-input association, table scope attributes, correct relative vs. absolute linking, and W3C validation pass; instructor confirms peer scores; pass mark 75%.
4	CSS Fundamentals: Selectors, the Box Model, and Cascade	15	demo	Students apply CSS rules using element, class, ID, descendant, and pseudo-class selectors, explain how specificity and cascade order resolve conflicts, and use the box model properties to control spacing and size.	Instructor-led specificity walkthrough: students predict the computed color of a series of elements given overlapping rules, then verify predictions in browser DevTools Computed panel. Box model measurement lab: students open a provided HTML page, use DevTools to measure margin, border, padding, and content dimensions of six targeted elements, record values in a worksheet, then write CSS to match a provided wireframe diagram. Cascade conflict debugging drill: students are given a broken CSS file with seven specificity conflicts; they must identify each conflict, explain why it occurs in a comment, and fix it so the page matches the reference screenshot.	VS Code, Chrome DevTools, MDN CSS Cascade and Inheritance reference, provided HTML page and broken CSS file, wireframe diagram handout	Debugging drill submitted file assessed against reference screenshot in DevTools; all seven conflicts resolved correctly scores 100%; pass mark 6 of 7 conflicts (approximately 85%) resolved correctly with accurate comments.
5	CSS Layouts: Flexbox and CSS Grid	16	lab	Students build multi-column and multi-row page layouts using CSS Flexbox and CSS Grid, correctly applying axis, alignment, sizing, and spanning properties.	Flexbox card-layout lab: students use Flexbox to build a product card gallery that wraps responsively, maintains equal card heights, and centers card content vertically — verified by resizing the browser window. CSS Grid page-layout lab: students implement a full page layout (header spanning all columns, a two-column content/sidebar area, and a footer) using named grid areas defined in grid-template-areas. Layout comparison writeup: students write a minimum 200-word explanation comparing when Flexbox is preferable to Grid and vice versa, supported by specific property-level examples from their two labs.	VS Code, Live Server, Chrome DevTools Grid and Flexbox overlays, CSS-Tricks Flexbox Guide and Grid Guide (css-tricks.com), Firefox Grid Inspector	Instructor loads both lab files and resizes the viewport; card gallery must wrap without overflow at three tested widths, and Grid layout must match the provided wireframe at desktop width; pass mark both layouts functional plus comparison writeup submitted.
6	Responsive Web Design and Media Queries	14	lab	Students implement a mobile-first responsive design using CSS media queries, viewport meta tag, flexible units, and fluid images so a page displays correctly on at least three viewport sizes.	Mobile-first refactor lab: students take a desktop-only CSS file and restructure it mobile-first — writing base styles for narrow screens, then adding min-width breakpoints for tablet and desktop — and document each breakpoint decision in code comments. Responsive image exercise: students implement a hero image section using max-width: 100%, height: auto for fluid scaling and test it at 375px, 768px, and 1280px in Chrome DevTools Device Mode, recording screenshots for the lab log. Cross-device checklist review: using a provided 15-point checklist (text legible without zoom, tap targets meet minimum size guidance, no horizontal scroll), students audit a classmate's responsive page and write a written summary of findings.	VS Code, Chrome DevTools Device Mode, MDN Responsive Design guide, provided desktop-only CSS starter file, responsive checklist handout, viewport meta tag reference	Instructor audits the mobile-first file using DevTools at 375px, 768px, and 1280px; all 15 checklist items must pass at each width; pass mark 13 of 15 items passing across all three viewports.
7	JavaScript Fundamentals: Variables, Data Types, Operators, and Control Flow	15	theory	Students write JavaScript using let/const, the six primitive data types, arithmetic and comparison operators, and if/else and switch control flow structures to solve defined logic problems.	Typed code-along: students follow along as the instructor writes and runs ten short scripts in the browser console covering type coercion edge cases, loose vs. strict equality, and operator precedence — students predict output before each run. Logic puzzle lab: students complete fifteen progressive coding challenges in a provided JS file (e.g., grade classifier, FizzBuzz variant, simple tip calculator) using only variables, operators, and control flow — no DOM yet. Error-reading exercise: students are given five scripts each containing a runtime or logical error; they must identify the error type, explain the cause in a comment, and fix the code so it produces the specified output.	VS Code, Chrome DevTools console, MDN JavaScript Guide (Grammar and types, Control flow chapters), provided challenge file and error-drill file	Auto-graded or instructor-checked output: all 15 logic challenges produce specified console output; all 5 error drills corrected; pass mark 17 of 20 items (85%) correct.
8	JavaScript Functions, Arrays, and Objects	14	lab	Students declare and invoke functions with parameters and return values, iterate over arrays using for loops and array methods, and create and access object properties to model structured data.	Function-writing lab: students write eight functions of increasing complexity (e.g., Celsius-to-Fahrenheit converter, word-count checker, discount calculator) with explicit return statements and test each in the browser console. Array methods workshop: working from MDN reference documentation, students use forEach, map, filter, and find to transform a provided array of product objects — filtering by price, mapping to a name list, and finding a specific item — then log results. Object modeling exercise: students design a JavaScript object literal representing a student record (name, courses array, GPA, isEnrolled boolean), write getter-style functions to format and return data from it, and explain the structure in inline JSDoc comments.	VS Code, Chrome DevTools console, MDN Array reference, MDN Functions guide, provided product dataset as a JS array literal, JSDoc reference	Instructor runs the submitted JS file in Node.js or the browser console; all eight functions return correct values for three test inputs each, and array method results match expected output; pass mark 80% of all test cases correct.
9	DOM Manipulation and Event Handling	16	lab	Students select DOM elements using querySelector and querySelectorAll, modify element content and attributes, create and append new elements, and attach event listeners to respond to user interactions.	DOM explorer lab: students use document.querySelector, getElementById, textContent, innerHTML (with XSS caution explained by instructor), setAttribute, and classList.add/remove to programmatically transform a static HTML page into a state matching a provided screenshot. Event listener project: students build a to-do list application entirely in vanilla JS — adding items via a form submit event, marking items complete with a click event that toggles a CSS class, and removing items with a button — with no third-party libraries. Event propagation experiment: students write code that demonstrates bubbling vs. capturing on a nested element structure, document their observations in the lab log, and apply stopPropagation() to solve a provided event-conflict problem.	VS Code, Live Server, Chrome DevTools Elements and Console panels, MDN DOM reference, MDN EventTarget.addEventListener reference, provided static HTML starter file	To-do list app demo: instructor performs add, complete-toggle, and delete operations; all three features must function without console errors; pass mark all three features working correctly plus lab log entry submitted.
10	Forms, Validation, and Fetch API Basics	14	lab	Students capture form input with JavaScript, perform client-side validation with user-facing error messages, and use the Fetch API with async/await to retrieve and display JSON data from a public REST endpoint.	Client-side validation lab: students add JavaScript validation to a multi-field registration form — checking required fields, email format with a regex pattern, and password minimum length — displaying error messages next to the relevant fields without page reload. Fetch API exercise: students use fetch() with async/await to call a public API (such as JSONPlaceholder or Open-Notify) and dynamically render the returned JSON data as HTML cards inserted into the DOM, including a loading state and a catch block for network errors. Security awareness discussion: instructor-led 20-minute session on why client-side validation is never a substitute for server-side validation, covering basic XSS injection concepts using a controlled demo in a sandboxed browser tab; students write a one-paragraph takeaway.	VS Code, Live Server, Chrome DevTools Network panel, MDN Fetch API reference, MDN Regular Expressions guide, JSONPlaceholder (jsonplaceholder.typicode.com) or another public API, provided starter form HTML	Validation lab: instructor attempts to submit the form with seven invalid input combinations; all seven must produce the correct inline error message; Fetch lab: API data renders correctly with visible loading state; pass mark both components functional.
11	Browser Developer Tools, Debugging, and Accessibility Auditing	14	demo	Students use browser DevTools to set breakpoints, step through JavaScript execution, inspect and edit CSS live, analyze network requests, and run a Lighthouse accessibility and performance audit.	Debugging walkthrough: instructor introduces a page with three planted JavaScript bugs (undefined variable reference, incorrect selector, off-by-one loop error); students use the DevTools Sources panel to set breakpoints, step through execution, and identify and fix each bug on their own machines. Live CSS editing challenge: students open a provided URL in Chrome, use the DevTools Elements panel to live-edit CSS so the page matches a target screenshot (color, font size, spacing), then copy the working CSS into a permanent stylesheet. Lighthouse audit lab: students run Lighthouse on their Lesson 6 responsive page, screenshot and interpret the Accessibility and Performance scores, identify the top two issues flagged in each category, and write a prioritized action list in the lab log.	Chrome DevTools (Sources, Elements, Network, Lighthouse tabs), Firefox DevTools as alternate reference, MDN Debugging JavaScript guide, provided buggy page files, Lighthouse documentation (developer.chrome.com)	All three bugs identified and fixed with correct explanations in code comments; Lighthouse action list contains at least four distinct actionable items with correct interpretation of the audit findings; pass mark all three bugs fixed plus action list complete.
12	Integrated Project: Multi-Page Responsive Website	14	practice	Students independently build, validate, and present a complete multi-page responsive website that integrates semantic HTML5, CSS3 layout, and JavaScript interactivity, meeting a provided specification document.	Project build: working independently over multiple sessions, students build a minimum three-page website (home, about, contact) for a provided client brief — must include semantic HTML, a responsive layout using Flexbox or Grid, at least one JavaScript interactive feature (e.g., form validation, dynamic content), and a Fetch API data display. Code review and self-audit: students run W3C validation and Lighthouse on all three pages, fix identified errors, and complete a self-assessment checklist covering semantic structure, accessibility, responsiveness, JavaScript functionality, and code commenting. Project defense: each student does a five-to-ten-minute live walkthrough of their site for the instructor and two peers, explaining at least three technical decisions (e.g., why Grid was chosen for a specific layout, how an event listener is structured), then answers two instructor questions.	VS Code, Live Server, Chrome DevTools, W3C Validator, Lighthouse, client brief specification document, project rubric, self-assessment checklist	Rubric scored by instructor across five domains: HTML validity and semantics (20%), CSS responsiveness (20%), JavaScript functionality (20%), accessibility/Lighthouse score (20%), and code quality and defense explanation (20%); pass mark 75% overall with no domain below 60%.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Web Concepts and ITF+ Alignment Knowledge Exam	Written exam	25%	70% correct (35 of 50 questions)	A 50-question multiple-choice and short-answer written exam covering the client-server model, HTTP, HTML5 and CSS3 concepts, JavaScript data types and control flow, DOM basics, and responsive design principles — mapped directly to CompTIA ITF+ exam objective areas for software development and web technologies. Students have 60 minutes; the exam is closed-book. Standard met · Safety · Time · Quality/finish · Documentation
Live Coding Skills Demonstration	Skills demonstration	45%	All four tasks completed and functional within the 90-minute session; partial credit available but minimum 3 of 4 tasks must be fully functional	The student receives a written specification and must build a working page from scratch in 90 minutes: a semantic HTML structure, a responsive CSS layout using Grid or Flexbox, a JavaScript interactive feature using DOM manipulation and an event listener, and a Fetch call that displays JSON data. The instructor evaluates the running page and reviews the code live at the end of the session. Standard met · Safety · Time · Quality/finish · Documentation
Course Lab Log Portfolio	Log	15%	At least 10 of 12 lessons represented with complete entries; average rubric score across all entries at or above 75%	Students maintain a running digital lab log (a Markdown file or structured document) with an entry for every lesson lab and demo, each containing: the lesson objective, the steps taken, screenshots of key results, errors encountered and how they were resolved, and a one-paragraph reflection. The complete portfolio is submitted at the end of the course and scored with a provided rubric. Standard met · Safety · Time · Quality/finish · Documentation
Ergonomics and Digital Workspace Safety Check	Safety audit	15%	All six mandatory safety items rated Satisfactory; any Unsatisfactory item requires correction and re-check before the student may continue to the next course	The instructor conducts a walkthrough of each student's physical and digital workspace using a standardized six-item checklist aligned to OSHA general industry ergonomics guidelines and Course 1 Universal Core safety content: monitor height and distance, chair posture support, keyboard and mouse position, lighting and glare control, cable management (trip hazard elimination), and screen break habits (compliance with the 20-20-20 rule). This check ensures safety habits established in the Universal Core are sustained in a development lab environment. Standard met · Safety · Time · Quality/finish · Documentation

TEC-WEB46-03 Trade course

PHP and Python Web Programming

171 hr · ~~$2,050~~ COMPLIMENTARY

Students learn server-side web development using PHP for dynamic web pages and database integration, and Python for scripting, automation, and web application logic. The course builds directly on HTML/CSS/JS foundations and prepares students for the PCEP Python credential exam while developing practical back-end skills used daily in web and software development roles.

Outcomes

Write syntactically correct PHP scripts that handle form data, session state, and file I/O using standard PHP functions
Write Python programs that use variables, control flow, functions, modules, and basic object-oriented constructs at the PCEP exam level
Connect a PHP or Python script to a MySQL/MariaDB database and perform parameterized CRUD operations safely
Identify and remediate common security vulnerabilities including SQL injection, cross-site scripting (XSS), and insecure file uploads in PHP and Python web code
Debug server-side scripts using error logs, print-tracing, and an IDE debugger, and document findings in a structured lab log
Explain how the request–response cycle works for a server-side application and describe the roles of the interpreter, web server, and browser

Course text

How the course runs. 12 blocks: How Server-Side Programming Works: The Request–Response Cycle; PHP Fundamentals: Syntax, Variables, Data Types, and Operators; PHP Control Flow, Functions, and Arrays; PHP Forms, Superglobals, and Input Validation; PHP Sessions, Cookies, and Authentication Basics; Python Fundamentals: Syntax, Variables, Data Types, and Operators; Python Control Flow, Functions, and Modules; Python Object-Oriented Programming and File I/O; Database Connectivity: PHP and Python with MySQL/MariaDB; Web Security: Common Vulnerabilities and Defensive Coding in PHP and Python; Python Scripting for Automation and API Consumption; Integrated Project: Dynamic PHP and Python Web Application.

What competent looks like. Write syntactically correct PHP scripts that handle form data, session state, and file I/O using standard PHP functions. Write Python programs that use variables, control flow, functions, modules, and basic object-oriented constructs at the PCEP exam level. Connect a PHP or Python script to a MySQL/MariaDB database and perform parameterized CRUD operations safely. Identify and remediate common security vulnerabilities including SQL injection, cross-site scripting (XSS), and insecure file uploads in PHP and Python web code. Debug server-side scripts using error logs, print-tracing, and an IDE debugger, and document findings in a structured lab log. Explain how the request–response cycle works for a server-side application and describe the roles of the interpreter, web server, and browser.

Lessons · 12 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	How Server-Side Programming Works: The Request–Response Cycle	9.5	theory	Students explain, without reference materials, how a browser request travels to a web server, is processed by a PHP or Python interpreter, and returns an HTTP response	Instructor-led diagram walkthrough: students label a blank request–response diagram (browser → DNS → web server → interpreter → database → response) and present their completed diagram to a partner Read Apache/Nginx official documentation sections on how CGI and FastCGI pass requests to interpreters; students annotate three key paragraphs and write a one-paragraph plain-language summary Hands-on comparison: students view the same URL with and without a running interpreter (stopping PHP-FPM deliberately) and record the error response, then restore service and document what changed	Apache HTTP Server docs, PHP manual (php.net), Python docs (docs.python.org), XAMPP or local Linux VM with Apache + PHP-FPM, whiteboard/digital diagram tool	Students submit a correctly labeled request–response diagram and written summary; both must accurately describe all major steps — graded pass/fail with 80% accuracy on a 10-point checklist
2	PHP Fundamentals: Syntax, Variables, Data Types, and Operators	13	demo	Students write PHP scripts that correctly declare variables, use all primitive data types, and apply arithmetic, comparison, and logical operators to produce expected output	Instructor live-codes a PHP script showing type juggling; students follow along in their own editor, modify values, and predict output before running — results are discussed as a class Students complete a structured drill: 20 short PHP snippets with deliberate type or operator errors; they identify and fix each error, noting the type of mistake in a log Pair programming exercise: partners build a tip-calculator PHP page that accepts a bill amount and tip percentage via URL query string and outputs the tip amount and total, using only PHP fundamentals covered so far	PHP manual (php.net/manual), VS Code with PHP Intelephense extension, local Apache + PHP environment, instructor-prepared error-drill worksheet	Tip-calculator page produces correct output for at least five test cases including edge cases (zero tip, decimal amounts); code review confirms proper variable naming and operator use — pass requires all five test cases to produce correct output
3	PHP Control Flow, Functions, and Arrays	13	lab	Students implement PHP programs using if/elseif/else, switch, for, while, foreach, and user-defined functions that accept parameters and return values, and manipulate indexed and associative arrays using built-in array functions	Guided lab: students build a grade-reporting script that reads an associative array of student names and numeric scores, uses a function to assign letter grades, and outputs an HTML table — instructor circulates and checks logic before students run the script Students use php.net to look up five array functions (array_map, array_filter, usort, array_slice, in_array) and write a short demonstration script for each, with comments explaining what the function does and why it is useful Debug challenge: instructor provides three broken PHP files with errors in loop logic and function return values; students use error_reporting(E_ALL) output and hand-tracing to diagnose and fix each file, documenting the bug and fix in their lab log	PHP manual (php.net/manual/en/ref.array.php), VS Code, local PHP environment, instructor-provided broken PHP files, student lab log template	Grade-reporting script produces correct letter grades and a valid HTML table for a provided test dataset of ten students; lab log entries for three debug challenges are complete and accurate — pass requires correct output and three complete log entries
4	PHP Forms, Superglobals, and Input Validation	13	lab	Students build PHP-powered HTML forms that collect user input via $_GET and $_POST, validate and sanitize input using filter functions, and display safe, meaningful error messages without exposing server details	Students build a multi-field registration form (name, email, age, password) with server-side PHP validation; they test with valid and invalid inputs and confirm all error messages appear correctly without a page crash Security demonstration: instructor submits a script tag as a form value to an unsanitized version of the form and displays the XSS result; students then add htmlspecialchars() and filter_input() to their own form and verify the attack no longer works Students read the OWASP Input Validation Cheat Sheet (owasp.org) and list five validation rules applicable to their registration form; they implement all five and document each rule and its corresponding PHP code in their lab log	PHP manual (filter functions), OWASP Input Validation Cheat Sheet (owasp.org), VS Code, local Apache + PHP environment, student lab log template	Registration form correctly validates all fields, rejects known-bad inputs (empty fields, invalid email format, non-numeric age, script-tag injection), and displays user-friendly errors — pass requires all five validation rules implemented and confirmed by instructor review
5	PHP Sessions, Cookies, and Authentication Basics	11.5	demo	Students implement PHP session management to maintain login state across pages and explain the security difference between storing data in sessions versus cookies	Instructor demonstrates session_start(), $_SESSION assignment, and session_destroy() by building a simple login/logout flow; students replicate the demo in their own environment and add a protected page that redirects unauthenticated users Students inspect browser developer tools to view the session cookie (PHPSESSID) and a manually set cookie; they record the difference in storage location, lifespan, and accessibility, and write a short comparison in their lab log Students harden their login page by adding password_hash() and password_verify() for credential storage and checking; they test with correct and incorrect passwords and confirm the hash is never displayed in output or logs	PHP manual (sessions, password functions), browser developer tools, VS Code, local PHP environment, student lab log template	Students demonstrate a working login/logout flow with a protected page; password is stored as a hash and verified correctly; lab log comparison of sessions vs. cookies is accurate — pass requires all three features working and lab log entry graded complete
6	Python Fundamentals: Syntax, Variables, Data Types, and Operators	14	demo	Students write Python 3 scripts that use correct syntax, all primitive data types (int, float, str, bool, NoneType), and arithmetic, comparison, logical, and bitwise operators, aligning with PCEP exam objective PE1 (Basics of Computer Programming and Python)	PCEP-aligned drill: students work through 30 short Python expressions predicting output before running in the REPL (interactive interpreter), covering integer division, string repetition, boolean short-circuit evaluation, and operator precedence — PCEP objective PE1 Instructor live-codes a unit-conversion script (miles to kilometers, Fahrenheit to Celsius) showing variable naming, type casting, and formatted string output (f-strings); students extend it to add two more conversions of their choice Students complete a timed 15-question multiple-choice quiz drawn from PCEP sample questions on data types and operators; results are reviewed as a class with explanations for wrong answers	Python 3 official docs (docs.python.org), Python Institute PCEP exam syllabus, VS Code with Python extension, Python REPL, PCEP sample questions	PCEP-style quiz score of 75% or higher (11/15); unit-conversion script runs without errors and produces correct output for all four conversions — both components must pass
7	Python Control Flow, Functions, and Modules	14	lab	Students write Python programs using if/elif/else, for and while loops, list comprehensions, user-defined functions with default and keyword arguments, and import statements for standard library modules, mapping to PCEP exam objectives PE2 and PE3	Students build a number-guessing game using a while loop, random module, and a function that validates input; they must handle non-integer input gracefully using a try/except block — PCEP objective PE3 (exception handling basics) PCEP-aligned function drill: students write ten functions of increasing complexity (factorial, palindrome check, Fibonacci sequence, list flattening) and annotate each with a docstring explaining parameters and return value — PCEP objective PE2 Module exploration lab: students use at least four standard library modules (math, os, datetime, random) in a single script that performs a practical task (e.g., a directory report showing file counts and dates); they document each module's role in their lab log	Python 3 docs, Python Institute PCEP exam syllabus, VS Code, Python REPL, student lab log template	Number-guessing game handles all edge cases correctly (non-integer, out-of-range, correct guess message); function drill produces correct output for all ten functions; lab log entries complete — pass requires all three deliverables accepted by instructor
8	Python Object-Oriented Programming and File I/O	13	lab	Students define Python classes with attributes, __init__, instance methods, and basic inheritance, and read and write text and CSV files using Python's built-in open() function and the csv module, aligning with PCEP supplemental objectives and foundational OOP concepts	Students design and implement a Product class with attributes (name, price, quantity), a method to calculate total value, and a subclass DiscountedProduct that overrides the price calculation; they write a test script that creates instances and prints results File I/O lab: students write a script that reads a CSV file of product records, creates Product objects, computes total inventory value, and writes a summary report to a new text file — they handle FileNotFoundError and malformed rows with try/except Peer code review: students exchange their Product class code with a partner, run it against a shared test dataset, and write two specific, constructive comments in the lab log about readability and correctness	Python 3 docs (csv module, built-in open()), instructor-provided CSV dataset, VS Code, student lab log template	Product and DiscountedProduct classes produce correct output for all test cases; file I/O script handles FileNotFoundError gracefully and writes a correct summary report; peer review comments are substantive — pass requires all three components complete and correct
9	Database Connectivity: PHP and Python with MySQL/MariaDB	15	lab	Students connect PHP scripts using PDO and Python scripts using mysql-connector-python to a MySQL/MariaDB database and execute parameterized SELECT, INSERT, UPDATE, and DELETE statements safely	Guided setup lab: students install and configure a local MySQL/MariaDB instance (or use a provided VM), create a database and a products table, and connect to it from both a PHP PDO script and a Python connector script — they verify the connection and handle connection errors CRUD lab: students build a PHP product-management page (list, add, edit, delete) and a matching Python CLI tool; both use parameterized queries exclusively — instructor demonstrates a SQL injection attack against a non-parameterized query before students write their own Students read the PHP PDO documentation section on prepared statements and the mysql-connector-python documentation section on parameterized queries; they write a one-page comparison of how each language implements parameterization and why it matters for security	PHP PDO docs (php.net/manual/en/book.pdo.php), mysql-connector-python docs (dev.mysql.com), MySQL/MariaDB, VS Code, local server environment	CRUD operations work correctly for all four operations in both PHP and Python; all queries use parameterization (instructor inspects code — no string concatenation in queries allowed); written comparison is accurate and complete — pass requires all criteria met
10	Web Security: Common Vulnerabilities and Defensive Coding in PHP and Python	13	theory	Students identify SQL injection, XSS, cross-site request forgery (CSRF), and insecure direct object reference vulnerabilities in provided code samples and apply the corresponding remediation technique in both PHP and Python	Students read the OWASP Top Ten overview (owasp.org) and for each of the four vulnerabilities covered in the lesson, write a one-paragraph plain-language explanation of the attack mechanism and one-sentence description of the defensive technique Vulnerability hunt: instructor provides four intentionally vulnerable PHP and Python code files (one per vulnerability); students identify the vulnerability, write a test input that would exploit it, then apply the remediation and confirm the attack no longer works Students add CSRF token generation and validation to their PHP product-management page from Lesson 9 and document the implementation steps in their lab log, explaining why CSRF tokens prevent the attack	OWASP Top Ten (owasp.org), PHP manual (CSRF, htmlspecialchars), Python docs, instructor-provided vulnerable code files, VS Code, student lab log template	Vulnerability hunt: all four vulnerable files correctly identified, exploited with a test input, and remediated; CSRF implementation is functional; written explanations are accurate — pass requires all four remediations working and explanations graded accurate by instructor
11	Python Scripting for Automation and API Consumption	14	lab	Students write Python scripts that automate a file-system task using os and shutil modules and consume a public REST API using the requests library, parsing JSON responses into Python data structures	File automation script: students write a Python script that scans a directory of mixed files, organizes them into subdirectories by file extension, logs a summary of actions taken to a timestamped log file, and handles permission errors gracefully API consumption lab: students use the requests library to query a free public REST API (such as the Open Meteo weather API or a similarly open, key-free API), parse the JSON response, and display formatted results — they handle HTTP error codes with appropriate messages Students write a brief technical document (one page) explaining what a REST API is, what JSON is, how the requests library sends an HTTP GET request, and how response data maps to Python dictionaries — this document goes into their lab log	Python docs (os, shutil, json modules), requests library docs (requests.readthedocs.io), free public REST API endpoint, VS Code, student lab log template	File automation script correctly organizes files and writes a log without crashing on permission errors; API script fetches and displays real data and handles at least one error code; technical document is accurate — pass requires all three deliverables accepted
12	Integrated Project: Dynamic PHP and Python Web Application	28	practice	Students design, build, test, and document a multi-page web application that uses PHP for the front-end server logic and a Python script for back-end data processing or automation, connected to a MySQL/MariaDB database with secure coding practices applied throughout	Project planning phase (hours 1–6): students produce a written project brief including a data dictionary (table names, columns, data types), a site map of at least four PHP pages, and a description of the Python component's role — instructor must approve the brief before coding begins Build phase (hours 7–22): students implement all PHP pages (including login/session management, CRUD operations, and input validation), the Python automation or processing script, and the database; they commit code to a local Git repository at the end of each lab session and document progress in their lab log Testing and documentation phase (hours 23–28): students conduct structured testing using a written test plan with at least ten test cases covering normal, boundary, and error conditions; they document all bugs found and fixes applied, and submit a final README that explains how to install and run the application	PHP manual, Python 3 docs, MySQL/MariaDB, VS Code, Git (local), OWASP references, student lab log and project brief templates	Application passes all ten test cases; no SQL injection or XSS vulnerabilities found by instructor review; Python script runs and produces correct output; README is complete and accurate; Git log shows at least eight commits — all criteria must be met to pass

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
PHP and Python Knowledge Exam	Written exam	25%	75% (38/50 questions correct)	A 50-question written exam covering PHP syntax and functions, Python data types and control flow, PCEP-aligned Python concepts (PE1–PE3), session management, parameterized database queries, and web security vocabulary; questions are multiple-choice and short-answer, and the exam is closed-book. Standard met · Safety · Time · Quality/finish · Documentation
Integrated Application Skills Demonstration	Skills demonstration	45%	Instructor marks all six rubric criteria as Met; any Unmet criterion requires a remediation attempt within five business days	Students present their Lesson 12 integrated project live to the instructor, demonstrating working login, CRUD operations, the Python component, and secure coding practices; they must answer three to five instructor questions about their code choices and explain at least one security decision. Standard met · Safety · Time · Quality/finish · Documentation
Lab Log Portfolio	Log	15%	At least 10 of 12 lessons have complete, accurate entries; entries for Lessons 4, 9, and 10 (security lessons) must all be present and accurate	Students submit their cumulative lab log containing entries from all 12 lessons; each entry must include the date, objective, steps taken, results observed, and any errors encountered with their resolution — the log is evaluated for technical accuracy, completeness, and honest reflection on mistakes. Standard met · Safety · Time · Quality/finish · Documentation
Secure Coding Safety Check	Safety audit	15%	All five security checks must pass; any failure requires immediate remediation and re-check before the student may submit the Lesson 12 project for final grading	Instructor performs a structured five-point security review of the student's Lesson 12 project: (1) all database queries use parameterization, (2) all output is HTML-escaped, (3) passwords are hashed with password_hash or equivalent, (4) a CSRF token is present on state-changing forms, and (5) no sensitive server information is exposed in error messages — each point is marked Pass or Fail. Standard met · Safety · Time · Quality/finish · Documentation

TEC-WEB46-04 Trade course

SQL and PostgreSQL Database Development

170 hr · ~~$2,040~~ COMPLIMENTARY

Students learn relational database theory and practical database development using SQL and PostgreSQL, progressing from schema design and data manipulation to advanced querying, indexing, transactions, and application integration. Emphasis is placed on data integrity, performance, and professional database administration practices used in web and software development workplaces. Lessons map to foundational computing concepts assessed in the CompTIA ITF+ exam and support the data-layer skills required in full-stack Python and PHP development.

Outcomes

Design and implement normalized relational database schemas using entity-relationship modeling and PostgreSQL DDL statements.
Write correct and efficient SQL queries using joins, subqueries, aggregates, window functions, and CTEs to retrieve and manipulate data.
Apply transaction control, constraints, and referential integrity rules to ensure consistent, reliable data storage.
Create and manage indexes, explain query execution plans, and tune queries for acceptable performance on realistic datasets.
Integrate a PostgreSQL database with a Python or PHP application using parameterized queries that prevent SQL injection.
Perform routine database administration tasks including user and role management, backup, restore, and environment configuration on a local PostgreSQL server.

Course text

How the course runs. 12 blocks: Relational Database Concepts and the PostgreSQL Environment; Data Definition Language: Designing and Creating Tables; Normalization and Entity-Relationship Modeling; Data Manipulation Language: INSERT, UPDATE, DELETE, and SELECT Basics; Joins and Multi-Table Queries; Aggregation, Grouping, Subqueries, and CTEs; Transactions, Constraints, and Data Integrity; Indexes, EXPLAIN, and Query Performance; Views, Stored Functions, and Triggers; PostgreSQL Administration: Users, Roles, Backup, and Restore; Application Integration: Python/PHP with PostgreSQL and SQL Injection Prevention; Capstone Lab: Full Database Design, Implementation, and Documentation.

What competent looks like. Design and implement normalized relational database schemas using entity-relationship modeling and PostgreSQL DDL statements. Write correct and efficient SQL queries using joins, subqueries, aggregates, window functions, and CTEs to retrieve and manipulate data. Apply transaction control, constraints, and referential integrity rules to ensure consistent, reliable data storage. Create and manage indexes, explain query execution plans, and tune queries for acceptable performance on realistic datasets. Integrate a PostgreSQL database with a Python or PHP application using parameterized queries that prevent SQL injection. Perform routine database administration tasks including user and role management, backup, restore, and environment configuration on a local PostgreSQL server.

Lessons · 12 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Relational Database Concepts and the PostgreSQL Environment	11.5	theory	Students will explain the relational model, identify the components of a DBMS, and successfully install and connect to a local PostgreSQL instance.	Read and annotate the PostgreSQL 16 official documentation sections covering architecture, processes, and data storage; answer a guided reading worksheet with 15 factual questions. Install PostgreSQL on a lab workstation, configure pg_hba.conf for local trust authentication, and connect via both psql and pgAdmin, documenting each step in a lab notebook. Complete a concept-mapping exercise that links terms—relation, tuple, attribute, primary key, foreign key, DBMS, schema, catalog—to their definitions and real-world analogies from web applications.	PostgreSQL 16 Community Documentation, lab workstations (Linux or Windows), pgAdmin 4, psql CLI, instructor slide deck, guided reading worksheet	Students answer 10 oral or written identification questions covering relational model vocabulary and can demonstrate a live psql connection; pass = 8/10 correct.
2	Data Definition Language: Designing and Creating Tables	13	demo	Students will create a multi-table database schema using correct DDL statements including CREATE TABLE, data type selection, and column constraints.	Instructor live-codes a bookstore database schema; students follow along in psql, then independently recreate the schema from memory and compare output of \\d tablename against a reference. Students select appropriate PostgreSQL data types (INTEGER, NUMERIC, VARCHAR, TEXT, BOOLEAN, DATE, TIMESTAMPTZ, UUID, JSONB) for 20 described columns on a worksheet, justifying each choice. Students write DDL scripts to CREATE, ALTER, and DROP tables for a provided entity list, adding NOT NULL, UNIQUE, DEFAULT, CHECK, PRIMARY KEY, and FOREIGN KEY constraints, then verify schema correctness using information_schema queries.	PostgreSQL 16 Documentation (Data Types chapter, DDL chapter), psql, pgAdmin, VS Code with SQLTools extension, constraint worksheet, instructor schema reference script	Students submit a .sql DDL script that executes without errors and matches a provided schema specification; pass = schema creates all tables with all required constraints, verified by automated \d output comparison.
3	Normalization and Entity-Relationship Modeling	13	theory	Students will apply first, second, and third normal form rules to decompose a denormalized dataset and produce a correct ER diagram.	Given a spreadsheet of unnormalized order data (repeating groups, partial dependencies, transitive dependencies), students identify violations and iteratively apply 1NF, 2NF, and 3NF rules, documenting each transformation step. Students draw an ER diagram for a provided business narrative (a small e-commerce site) using draw.io or Lucidchart, identifying entities, attributes, primary keys, and relationships with correct crow's-foot cardinality notation. Peer-review activity: pairs exchange ER diagrams, check for normalization violations and missing relationships, then deliver a short verbal critique; instructor resolves disagreements against a model answer.	draw.io or Lucidchart (browser-based), normalization worksheet with sample denormalized dataset, instructor ER diagram rubric, Martin/Fowler relational modeling reference handout	Submitted ER diagram is graded against a rubric: all entities identified, all relationships correct, all cardinalities labeled, schema is at least 3NF; pass = 80% of rubric points earned.
4	Data Manipulation Language: INSERT, UPDATE, DELETE, and SELECT Basics	13	lab	Students will write correct DML statements to insert, update, delete, and retrieve rows, using WHERE clauses and comparison operators accurately.	Load a provided seed SQL script (500-row sample dataset for a library database) into a lab schema and verify row counts using SELECT COUNT(*); troubleshoot any import errors by reading PostgreSQL error messages. Complete a 30-item DML exercise set: write INSERT statements with explicit column lists, UPDATE statements with precise WHERE conditions, and DELETE statements, checking before-and-after row counts to confirm correct execution. Write 15 SELECT queries of increasing complexity using WHERE, AND, OR, NOT, BETWEEN, IN, LIKE, IS NULL, and ORDER BY; compare results against an instructor answer key and debug any discrepancies.	Library sample dataset seed script (instructor-provided), psql, pgAdmin, DML exercise worksheet, PostgreSQL DML documentation chapter	Students pass a timed 20-query practical check: each query must return the exact result set shown in the answer key; pass = 16/20 queries producing correct output.
5	Joins and Multi-Table Queries	15	lab	Students will retrieve data from multiple related tables using INNER JOIN, LEFT JOIN, RIGHT JOIN, FULL OUTER JOIN, and CROSS JOIN, correctly interpreting result sets.	Work through an instructor-designed join visualization exercise: draw Venn-style diagrams by hand for each join type given a two-table example, then verify predicted row counts by running queries against the library dataset. Write a series of 20 progressively complex join queries against the library schema—joining two, three, and four tables—including queries that filter on joined columns and alias tables for readability. Debug a set of 8 intentionally broken join queries (wrong join type, missing ON condition, Cartesian product produced accidentally): identify the defect, explain it in a comment, and write the corrected version.	Library dataset (from Lesson 4), psql, pgAdmin, join exercise worksheet with expected row counts, instructor answer key	Students complete a 15-query join quiz on a fresh schema; each query is auto-checked by row count and sample values; pass = 12/15 queries producing correct result sets.
6	Aggregation, Grouping, Subqueries, and CTEs	15	lab	Students will use GROUP BY, HAVING, aggregate functions, correlated and non-correlated subqueries, and CTEs to answer analytical questions against relational data.	Answer 15 business questions about the library dataset (e.g., 'Which branch has the highest average loans per month?') using GROUP BY with COUNT, SUM, AVG, MIN, MAX, and HAVING filters; annotate each query with a plain-English explanation. Rewrite three aggregation queries first as correlated subqueries, then as CTEs using WITH clauses; compare readability and discuss trade-offs in a short written reflection (one paragraph per rewrite). Complete a challenge exercise: write a single CTE chain of three named queries that computes a ranked top-5 list, using ROW_NUMBER() or RANK() as an introduction to window functions, and explain the output row by row.	Library dataset, psql, pgAdmin, aggregation and CTE exercise worksheet, PostgreSQL Aggregate Functions documentation page	Students submit annotated .sql files; instructor runs each query and checks output against answer key; pass = 80% of queries returning correct results with correct SQL constructs used.
7	Transactions, Constraints, and Data Integrity	13	demo	Students will use BEGIN, COMMIT, ROLLBACK, and SAVEPOINT to manage transactions and explain how ACID properties protect data integrity.	Instructor demonstrates a bank-transfer scenario (debit one account, credit another) with and without transaction wrapping; students reproduce the demo and intentionally simulate a mid-transaction failure to observe the rolled-back state. Students write a transaction script that inserts records across three related tables and includes a SAVEPOINT; they deliberately trigger a constraint violation after the savepoint and roll back only to the savepoint, then commit the valid portion. Complete a written ACID worksheet: for each of 10 real-world scenarios (e.g., double-booking a seat, concurrent balance reads), identify which ACID property is at risk and which PostgreSQL feature (constraint, transaction isolation level, lock) addresses it.	Bank-transfer demo script (instructor-provided), PostgreSQL Transaction Isolation documentation, ACID worksheet, psql	Students demonstrate a live transaction scenario chosen at random from a set of five; they must execute it correctly, trigger and handle a rollback, and verbally explain what each statement does; pass = all steps executed correctly with correct verbal explanation.
8	Indexes, EXPLAIN, and Query Performance	13	theory	Students will create B-tree indexes, interpret EXPLAIN ANALYZE output, and identify at least two query patterns that benefit from indexing on a provided dataset.	Run EXPLAIN ANALYZE on five slow queries against a 50,000-row dataset (instructor-provided); read and annotate the query plan output, identifying sequential scans, index scans, cost estimates, and actual row counts. Add B-tree indexes to columns identified as bottlenecks; re-run EXPLAIN ANALYZE and record before/after planning and execution times in a performance log table (index name, query, before cost, after cost, observation). Research and present a three-minute verbal explanation of when NOT to index (low-cardinality columns, write-heavy tables, small tables) using the PostgreSQL documentation and one external reference; classmates ask two follow-up questions each.	50,000-row performance dataset seed script (instructor-provided), PostgreSQL EXPLAIN documentation, psql, pgAdmin Query Tool, performance log template	Students submit a completed performance log with at least five entries showing measurable cost reduction; pass = log contains accurate before/after data and a correct written interpretation for each index created.
9	Views, Stored Functions, and Triggers	13	demo	Students will create updatable and non-updatable views, write PL/pgSQL functions with parameters, and implement a simple audit trigger.	Create three views of increasing complexity against the library schema: a simple column-subset view, a view with a join, and a view with aggregation; test updateability of each view and document the PostgreSQL rules that determine it. Write a PL/pgSQL function that accepts two parameters (start_date, end_date) and returns a table of overdue loans using RETURNS TABLE syntax; test with multiple input combinations and verify output matches a manual query. Implement an audit trigger on a BEFORE UPDATE event for the books table that writes the old row, new row, and CURRENT_TIMESTAMP to an audit_log table; demonstrate it firing by executing several UPDATE statements and querying the log.	Library dataset, PostgreSQL PL/pgSQL documentation, psql, pgAdmin, instructor view and trigger reference examples	Students submit .sql files containing the view definitions, function, and trigger; instructor executes a test script that calls the function and fires the trigger; pass = all objects execute without error and return correct results.
10	PostgreSQL Administration: Users, Roles, Backup, and Restore	13	lab	Students will create database roles with appropriate privileges, perform a full database backup using pg_dump, and restore it to a new database.	Create three roles (read_only, read_write, admin) using CREATE ROLE and GRANT statements; verify access by connecting to the database as each role and attempting permitted and restricted operations, recording results in a security matrix. Use pg_dump to export the library database in both plain-text SQL and custom (-Fc) formats; verify the dump file is valid by checking its header and size, then restore the custom-format dump to a new library_restored database using pg_restore. Write a one-page administration runbook documenting the backup schedule, restore procedure, and role definitions for the library database as if handing it off to a new developer; peer-review for completeness and accuracy.	PostgreSQL pg_dump and pg_restore documentation, psql, lab workstations, administration runbook template, instructor security matrix worksheet	Instructor executes a live restore from the student's .dump file into a clean database and runs a row-count verification script; pass = all tables restore with correct row counts and the role security matrix is complete and accurate.
11	Application Integration: Python/PHP with PostgreSQL and SQL Injection Prevention	15	lab	Students will connect a Python or PHP application to PostgreSQL using a database driver, execute parameterized queries, and demonstrate that the code is not vulnerable to SQL injection.	Use psycopg2 (Python) or PDO (PHP) to write a script that connects to the library database, retrieves rows matching a user-supplied search term using a parameterized query, and prints formatted results to the terminal. Demonstrate the SQL injection vulnerability by first writing the search query using string concatenation, then attempt an injection payload (e.g., ' OR '1'='1); document the result, then fix the code with parameterized queries and show the injection attempt is neutralized. Build a small command-line CRUD application (create, read, update, delete a book record) using parameterized queries, error handling (try/except or try/catch), and connection pooling or context-manager-style connection management.	Python 3 with psycopg2, or PHP 8 with PDO, library database, VS Code, OWASP SQL Injection Prevention Cheat Sheet, instructor integration code scaffold	Students present their CRUD application; instructor enters a SQL injection payload into the search field and verifies it does not affect the database; pass = application performs all four CRUD operations correctly and injection attempt produces no unintended results.
12	Capstone Lab: Full Database Design, Implementation, and Documentation	22.5	lab	Students will independently design, build, populate, query, and document a complete PostgreSQL database for an assigned business scenario, demonstrating all skills developed in the course.	Receive an assigned business scenario (e.g., a community events booking system); produce a written requirements document, a normalized ER diagram, and a complete DDL script creating all tables, constraints, and at least one view and one function. Populate the database with at least 200 rows of realistic seed data (using INSERT scripts or a Python/PHP seed script), then write and annotate 10 queries answering specific business questions provided in the scenario brief, including at least one CTE and one aggregation with HAVING. Write a two-page technical documentation report covering: schema design decisions, normalization rationale, index choices with EXPLAIN evidence, role and privilege design, and backup procedure; present findings in a 10-minute live defense to the instructor and two peers.	Scenario brief (instructor-provided), PostgreSQL 16, psql, pgAdmin, draw.io, VS Code, documentation template, EXPLAIN ANALYZE, pg_dump	Rubric scores DDL correctness (25%), query correctness (25%), normalization and ER diagram (20%), documentation quality (15%), and oral defense (15%); pass = 80% of total rubric points earned and all queries return correct results when run by instructor.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
SQL and Database Concepts Knowledge Exam	Written exam	25%	75% (38/50 questions correct)	A 50-question written exam covering relational model theory, normalization rules, SQL syntax (DDL, DML, joins, aggregates, transactions), PostgreSQL-specific features (data types, PL/pgSQL, EXPLAIN), ACID properties, and security concepts including SQL injection; questions are multiple-choice and short-answer. This assessment maps to CompTIA ITF+ exam objectives covering database concepts and data management fundamentals. Standard met · Safety · Time · Quality/finish · Documentation
Practical Database Build Skills Demonstration	Skills demonstration	45%	All four required tasks completed correctly with no data integrity errors	Given a fresh schema specification and seed dataset, students have 90 minutes to write a DDL script, load data, write four specified queries (including a join, an aggregate, and a CTE), and create one index; the instructor runs all artifacts against an automated verification script. This timed performance demonstration reflects the database development tasks students will encounter in entry-level development and IT support roles. Standard met · Safety · Time · Quality/finish · Documentation
Lab Notebook and Query Log	Log	15%	80% of lab log entries complete and accurate (instructor rubric)	Students maintain a running lab log throughout the course documenting every lab session: the task attempted, SQL statements written, errors encountered, solutions applied, and EXPLAIN output records for performance lessons; entries must be timestamped and written in clear technical English. The log is evaluated for completeness, accuracy, professional formatting, and evidence of reflective troubleshooting rather than just copying instructor solutions. Standard met · Safety · Time · Quality/finish · Documentation
Data Security and Safe Practices Check	Safety audit	15%	Pass: all five security checkpoints met; Fail: any checkpoint not met requires remediation before course completion	Instructor evaluates five checkpoints against the student's capstone database: (1) no plaintext passwords stored in application connection strings or scripts; (2) all application queries use parameterized statements with no string concatenation of user input; (3) least-privilege roles assigned—application role cannot DROP tables; (4) a verified backup dump file exists and restores cleanly; (5) sensitive columns (e.g., email) are not exposed in public-facing views without access control. This check maps to professional data stewardship standards expected in all web development roles. Standard met · Safety · Time · Quality/finish · Documentation

TEC-WEB46-05 Trade course

Git Version Control for Web & Software Development

170 hr · ~~$2,040~~ COMPLIMENTARY

This course teaches students to use Git as a professional version control system, covering local repository management, branching strategies, remote collaboration via GitHub/GitLab, and team workflows used in production web and software environments. Students practice real-world scenarios including merge conflict resolution, pull request reviews, and release tagging. Lessons map to CompTIA ITF+ exam objectives covering software development concepts and collaboration tools.

Outcomes

Initialize and manage local Git repositories, stage and commit changes, and interpret repository history using git log and related commands.
Create, merge, and delete branches using standard branching strategies such as Git Flow and trunk-based development.
Resolve merge conflicts manually and verify repository integrity after conflict resolution.
Push, pull, fetch, and clone repositories using remote hosts including GitHub and GitLab, and manage remote tracking branches.
Conduct and respond to pull request reviews following industry code-review standards, including writing meaningful commit messages and PR descriptions.
Apply repository security practices including .gitignore configuration, removal of sensitive data from history, and use of SSH keys for remote authentication.

Course text

How the course runs. 12 blocks: What Version Control Does and Why It Matters; Installing Git and Configuring the Environment; Creating Repositories and Recording Changes; Viewing and Navigating History; Branching: Creating, Switching, and Merging; Resolving Merge Conflicts; Working with Remote Repositories; Pull Requests and Code Review Workflow; Branching Strategies: Git Flow and Trunk-Based Development; Tags, Releases, and Semantic Versioning; Repository Security: .gitignore, Sensitive Data, and SSH; Integrated Git Workflow Simulation.

What competent looks like. Initialize and manage local Git repositories, stage and commit changes, and interpret repository history using git log and related commands. Create, merge, and delete branches using standard branching strategies such as Git Flow and trunk-based development. Resolve merge conflicts manually and verify repository integrity after conflict resolution. Push, pull, fetch, and clone repositories using remote hosts including GitHub and GitLab, and manage remote tracking branches. Conduct and respond to pull request reviews following industry code-review standards, including writing meaningful commit messages and PR descriptions. Apply repository security practices including .gitignore configuration, removal of sensitive data from history, and use of SSH keys for remote authentication.

Lessons · 12 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	What Version Control Does and Why It Matters	10	theory	Students explain the purpose of version control, describe the difference between centralized and distributed systems, and identify the role of Git in modern software development.	Read and annotate the first two chapters of the Pro Git book (Chacon & Straub, freely available at git-scm.com), then answer a set of comprehension questions covering distributed vs. centralized VCS, snapshots vs. deltas, and the three states of a Git file. Participate in a class discussion comparing a scenario of sharing code via email attachments versus using Git, identifying specific problems Git solves such as version history, rollback, and parallel work. Complete a matching exercise that pairs Git terminology (working tree, staging area, repository, commit, HEAD) with plain-language definitions, then self-grade using the answer key.	Pro Git book (git-scm.com/book), whiteboard, printed terminology matching worksheet, internet-connected workstations	Score of 80% or higher on a 20-question written quiz covering VCS concepts, Git's distributed model, and the three-state file lifecycle.
2	Installing Git and Configuring the Environment	12	lab	Students install Git on a Linux or Windows workstation, configure global user identity and preferred editor, and verify the installation produces a functional git version output.	Follow a step-by-step installation guide to install Git via the package manager on a Linux VM (apt install git or dnf install git) and verify with git --version; document the installed version in a lab log entry. Run git config --global commands to set user.name, user.email, core.editor, and default branch name, then use git config --list to confirm all settings and record the output in the lab log. Generate an SSH key pair using ssh-keygen, add the public key to a personal GitHub account, and test the connection with ssh -T git@github.com, logging the success or troubleshooting steps taken.	Linux VM or Windows workstation with terminal access, Git installer, GitHub account (free tier), lab log template (digital or printed)	Instructor inspects each student's git config --list output and confirms SSH test returns authenticated successfully; lab log entry signed off by instructor.
3	Creating Repositories and Recording Changes	16	lab	Students initialize a local repository, add files to the staging area, write well-formed commit messages, and inspect repository status and history using git status and git log.	Create a new project directory, run git init, create three HTML files representing a simple webpage, stage each file individually with git add, and commit with a descriptive message following the conventional commit format (type: subject line, body explaining why). Modify one file, run git status and git diff to observe unstaged and staged changes, then stage and commit the change; repeat for two additional edits and compare all commits using git log --oneline --graph. Practice undoing changes: use git restore to discard a working-tree edit, git restore --staged to unstage a file, and git revert to create a new commit that undoes a previous commit; document each command and its result in the lab log.	Git-configured workstation, terminal, text editor (VS Code or nano), lab log, Pro Git book chapter 2	Repository contains at least six meaningful commits with correctly formatted messages; git log output reviewed by instructor; lab log entry earns instructor sign-off; 80% pass threshold on embedded checkpoint quiz.
4	Viewing and Navigating History	12	demo	Students use git log filtering options, git show, and git diff to locate specific commits, compare versions of a file, and interpret the output of each command accurately.	Instructor demonstrates git log with flags --oneline, --graph, --all, --author, --since, --grep, and --follow on a prepared sample repository; students follow along on their own terminals and answer a guided worksheet about what each flag does. Students use git diff HEAD~2 HEAD -- filename to compare a file across two commits, interpret the unified diff output (+ and - lines), and write a short plain-language summary of what changed between those two commits. Use git show <commit-hash> to inspect a specific commit's metadata and patch, then use git log --all --oneline to locate a commit that introduced a specific keyword using grep piped output; record findings in the lab log.	Prepared sample Git repository (provided by instructor), terminal, printed unified-diff reference card, lab log	Students correctly answer 8 of 10 questions on a worksheet requiring them to interpret git log and git diff output from printed screenshots; lab log entry signed off.
5	Branching: Creating, Switching, and Merging	18	lab	Students create and switch between branches, perform fast-forward and three-way merges, and delete branches after successful integration.	Starting from a provided repository representing a small website, create a feature branch named feature/navigation, add a navigation bar to the HTML, commit the change, then merge it into main using git merge and observe whether a fast-forward or a merge commit occurs. Create a second branch named feature/footer from main, commit changes to the footer file, then switch to main and commit an unrelated change to a different file; merge feature/footer into main to trigger a three-way merge commit and examine the resulting graph with git log --graph --oneline --all. Delete merged branches with git branch -d and attempt to delete an unmerged branch with git branch -d to observe the safety warning; document the difference between -d and -D flags in the lab log with a note on when force-delete is appropriate.	Git workstation, provided starter repository, terminal, VS Code, lab log, Pro Git book chapter 3	Instructor inspects repository graph showing correct fast-forward and three-way merge commits; lab log entry complete; student verbally explains the difference between the two merge types to instructor satisfaction.
6	Resolving Merge Conflicts	16	lab	Students identify conflict markers in conflicted files, manually resolve conflicts by editing file content, mark the resolution with git add, and complete the merge with a commit.	Instructor creates a prepared repository where two branches have made incompatible edits to the same lines of style.css; students attempt the merge, observe the CONFLICT message, and open the file to identify the <<<<<<<, =======, and >>>>>>> markers. Students resolve the conflict by deciding which changes to keep (or combining both), remove all markers, save the file, run git add style.css, and complete the merge with git commit; run git log --graph --oneline to confirm the merge commit appears correctly. Repeat the exercise with a second prepared conflict scenario involving a JavaScript file; this time students write a brief written explanation in their lab log of the reasoning behind their resolution decision, simulating a professional code review note.	Prepared conflicted repositories (two scenarios provided by instructor), terminal, VS Code with GitLens extension installed, lab log	Repository shows a clean merge commit with no remaining conflict markers (verified by instructor running git diff on the result); lab log reasoning entry present; student answers three oral questions about conflict resolution to 80% accuracy.
7	Working with Remote Repositories	16	lab	Students clone a remote repository, add and inspect remotes, push local branches to a remote, fetch and pull changes from a remote, and manage remote-tracking branches.	Clone a provided GitHub repository using git clone with the SSH URL, inspect the remote configuration with git remote -v, and push a new local branch to the remote using git push -u origin feature/about-page; confirm the branch appears on GitHub. Simulate a teammate's change by having a partner (or the instructor) push a commit to the main branch on GitHub; students run git fetch origin to retrieve the changes without merging, examine origin/main with git log origin/main, then run git merge origin/main to integrate the update. Practice git pull (which combines fetch and merge) versus git fetch followed by git log --oneline HEAD..origin/main to preview incoming changes before merging; document in the lab log when each approach is preferable in a team setting.	GitHub accounts, SSH keys configured in Lesson 2, terminal, internet connection, lab log	Instructor verifies the student's GitHub repository shows the pushed branch and a subsequent merged pull with correct history; lab log entry complete and signed off.
8	Pull Requests and Code Review Workflow	16	practice	Students open a pull request on GitHub, write a descriptive PR description, respond to review comments, request and conduct a peer code review, and merge the PR using the GitHub interface.	Each student pushes a feature branch to a shared class repository and opens a pull request using the GitHub web interface, writing a title and description that explains what changed, why it changed, and any testing done, following a provided PR template. Students are paired to review each other's pull requests: they leave at least two inline code comments using GitHub's review tool, at least one suggesting a concrete improvement, and then submit the review as either Approve or Request Changes with a summary comment. Students address at least one review comment by pushing an additional commit to the branch, then the reviewer approves and the original author merges the PR using the Squash and Merge option; both students record the PR number and merge strategy in their lab logs.	GitHub shared class repository (instructor-created), GitHub web interface, terminal, PR description template (provided), lab log	PR contains a complete description, at least one review exchange is documented, the merge is completed with no broken files; instructor reviews the PR thread and lab log entry; 80% of evaluation rubric criteria met.
9	Branching Strategies: Git Flow and Trunk-Based Development	12	theory	Students compare Git Flow and trunk-based development branching strategies, identify the branch naming conventions and rules for each, and select an appropriate strategy given a described project scenario.	Read the original Git Flow blog post by Vincent Driessen (nvie.com/posts/a-successful-git-branching-model) and a counterpoint article on trunk-based development (trunkbaseddevelopment.com); complete a two-column comparison chart listing the main branches, merge rules, release process, and ideal project type for each. Instructor presents three project scenarios (a large e-commerce platform with scheduled releases, a small startup doing continuous deployment, a solo developer on a personal project) and students work in groups to argue which strategy fits each scenario best, presenting their reasoning to the class. Students sketch a branch diagram on paper for a hypothetical four-week feature release using Git Flow, labeling main, develop, feature, release, and hotfix branches with arrows showing merge direction; diagrams are peer-reviewed for accuracy.	Printed or on-screen articles, comparison chart worksheet, whiteboard, markers, blank paper for diagrams	Comparison chart is complete and accurate; branch diagram contains all required branch types with correct merge directions; student earns 80% on a 10-question scenario-matching quiz.
10	Tags, Releases, and Semantic Versioning	10	demo	Students create lightweight and annotated Git tags, push tags to a remote, interpret semantic version numbers, and create a GitHub Release tied to an annotated tag.	Instructor demonstrates creating a lightweight tag with git tag v0.1 and an annotated tag with git tag -a v1.0.0 -m 'First stable release', explains the difference between the two types, and pushes both to GitHub with git push origin --tags; students replicate the steps on their own repositories. Students interpret a table of semantic version numbers (MAJOR.MINOR.PATCH), identify which component changes for a bug fix, a backward-compatible new feature, and a breaking change, and write the correct next version number for five described change scenarios. Each student creates a GitHub Release on their course repository by navigating to Releases, creating a new release from their annotated tag, writing a changelog-style release description, and publishing it; they record the release URL in their lab log.	Git workstation, GitHub account, terminal, semantic versioning reference (semver.org), lab log	GitHub repository shows at least two tags (one lightweight, one annotated) and a published GitHub Release with a readable changelog; lab log entry signed off; scenario quiz score 80% or higher.
11	Repository Security: .gitignore, Sensitive Data, and SSH	16	lab	Students configure a .gitignore file to exclude sensitive and build files, verify that tracked sensitive data can be removed from history using git filter-repo or BFG, and confirm SSH authentication is used for all remote operations.	Given a repository that has accidentally committed a file named .env containing fake API keys and database credentials, students add .env to .gitignore, then use the git filter-repo tool (or BFG Repo-Cleaner) to purge the file from all history, and force-push the cleaned repository; they verify the file no longer appears in any commit with git log --all --full-history -- .env. Build a comprehensive .gitignore for a Python/PHP web project using gitignore.io, covering OS files (Thumbs.db, .DS_Store), editor files (.vscode/, .idea/), language artifacts (__pycache__/, *.pyc, vendor/), and environment files (.env); commit the .gitignore and test that a newly created .env file is correctly ignored. Audit the remote URL of their repository with git remote -v to confirm it uses the SSH format (git@github.com:...) rather than HTTPS, rotate their SSH key by generating a new pair with ssh-keygen, add the new public key to GitHub, and remove the old key from GitHub settings; test the new key with ssh -T git@github.com.	Git workstation, terminal, git-filter-repo (pypi.org/project/git-filter-repo), gitignore.io, GitHub settings page, lab log	Instructor confirms .env is absent from all commits using git log --all check; .gitignore covers all required categories; SSH test passes with new key; lab log entry complete; 80% score on a 10-question security-scenario quiz.
12	Integrated Git Workflow Simulation	16	practice	Students execute a complete team development workflow from repository setup through tagged release, including branching, conflict resolution, pull request review, and final merge, demonstrating proficiency across all course skills.	Working in teams of three, students set up a shared GitHub repository with branch protection rules on main (requiring pull request reviews before merge), then each member creates a feature branch to contribute a distinct section of a static website (header, main content, footer), pushing branches and opening pull requests for peer review. The instructor introduces a deliberate merge conflict between two feature branches by editing the same line of index.html; the team must communicate, resolve the conflict collaboratively, and document the resolution process in their lab logs, recording which Git commands they used at each step. After all features are merged, students create a develop branch merge into main via a PR, apply a semantic version annotated tag (v1.0.0), publish a GitHub Release with a written changelog, and present a 10-minute walkthrough of their repository history and workflow decisions to the class using git log --graph --oneline --all.	GitHub shared team repository, terminal, VS Code with GitLens, lab log, presentation display, Pro Git book for reference	Repository shows correct branch history, resolved conflicts, merged PRs, annotated tag, and published release; team walkthrough covers all required workflow steps; instructor rubric requires 80% of criteria met; each student's individual lab log is complete.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Git Concepts Knowledge Exam	Written exam	25%	80% (40 of 50 points)	A 50-question written exam covering Git terminology, the three-state file model, branching and merging concepts, remote repository operations, semantic versioning, branching strategies (Git Flow vs. trunk-based), and repository security practices, mapped to CompTIA ITF+ exam objective areas related to software development concepts and collaboration tools. Questions include multiple choice, true/false, and short-answer interpretation of git log and git diff output. Standard met · Safety · Time · Quality/finish · Documentation
Live Git Workflow Skills Demonstration	Skills demonstration	45%	Pass requires completing all 6 required tasks within 60 minutes with no critical errors; partial-credit rubric scores 80% minimum	The student is given a prepared repository and a written scenario sheet describing a feature request; they must initialize or clone a repo, create a correctly named branch, make and commit changes with a properly formatted commit message, simulate and resolve a merge conflict, push to a remote, and open a pull request with a complete description, all observed and scored in real time by the instructor using a rubric. Standard met · Safety · Time · Quality/finish · Documentation
Lab Log Portfolio	Log	15%	All 12 lesson lab log entries present with instructor sign-off; 80% of rubric criteria met across the portfolio	Students submit their complete lab log collected across all 12 lessons, containing documented command output, written reasoning for decisions made (such as conflict resolution choices and .gitignore categories), and instructor sign-offs; the portfolio is evaluated for completeness, accuracy of recorded command output, and clarity of written explanations. Standard met · Safety · Time · Quality/finish · Documentation
Repository Security Safety Check	Safety audit	15%	All five mandatory items must pass; any mandatory failure requires remediation and recheck before course completion	The instructor audits each student's final course repository against a five-item checklist: (1) .env and build artifacts are listed in .gitignore and untracked; (2) no credentials appear in any commit in git log --all history; (3) remote URL uses SSH not HTTPS; (4) SSH key is present and tested successfully; (5) branch protection rules requiring PR review are enabled on main; this check maps to professional security standards for source code management and supports safe remote collaboration practices. Standard met · Safety · Time · Quality/finish · Documentation

TEC-WEB46-06 Trade course

Linux/Bash for Web & Software Development

170 hr · ~~$2,040~~ COMPLIMENTARY

Students gain hands-on proficiency with the Linux operating system and Bash shell scripting as applied to web and software development workflows. Topics span filesystem navigation, user and permission management, process control, networking utilities, and automated scripting, all aligned to CompTIA Linux+ exam objectives. Emphasis is placed on safe system administration practices and real-world DevOps tasks developers encounter daily.

Outcomes

Navigate and manage the Linux filesystem, users, groups, and file permissions using standard command-line tools with no critical errors.
Write and execute Bash scripts that automate repetitive development tasks such as backups, log parsing, and build steps.
Configure and troubleshoot basic Linux networking, including interface inspection, DNS resolution, and firewall rules with ufw.
Manage software packages, system services, and scheduled jobs using the tools appropriate to a Debian/Ubuntu environment.
Interpret and modify shell environment variables, PATH, and startup files to support a development-ready Linux workstation.
Apply secure system administration habits—least-privilege principle, SSH key authentication, and safe sudo usage—consistent with CompTIA Linux+ security objectives.

Course text

How the course runs. 12 blocks: Linux Landscape: History, Distributions, and the Shell; Filesystem Navigation and Basic Commands; Users, Groups, and File Permissions; Text Processing: grep, sed, awk, and Pipelines; Bash Scripting Fundamentals; Advanced Bash: Input Validation, Error Handling, and Scheduling; Package Management and Software Installation; System Services and Process Management; Linux Networking for Developers; SSH, Remote Access, and Key-Based Authentication; Shell Environment, Variables, and Startup Files; Capstone Integration Lab: Linux Server Provisioning Script.

What competent looks like. Navigate and manage the Linux filesystem, users, groups, and file permissions using standard command-line tools with no critical errors. Write and execute Bash scripts that automate repetitive development tasks such as backups, log parsing, and build steps. Configure and troubleshoot basic Linux networking, including interface inspection, DNS resolution, and firewall rules with ufw. Manage software packages, system services, and scheduled jobs using the tools appropriate to a Debian/Ubuntu environment. Interpret and modify shell environment variables, PATH, and startup files to support a development-ready Linux workstation. Apply secure system administration habits—least-privilege principle, SSH key authentication, and safe sudo usage—consistent with CompTIA Linux+ security objectives.

Lessons · 12 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Linux Landscape: History, Distributions, and the Shell	10	theory	Students will explain the role of the Linux kernel, common distributions, and the purpose of the shell in a web development context.	Guided reading of the Linux Foundation's 'Introduction to Linux' chapter on kernel vs. distribution vs. desktop environment; students annotate a comparison table of Ubuntu, Debian, CentOS Stream, and Fedora. Instructor-led demo: boot a VirtualBox Ubuntu 22.04 LTS VM, identify version with 'uname -r' and 'lsb_release -a', then locate the same information in /etc/os-release. Small-group discussion: map each distro to a real-world use case (web server, desktop dev, embedded); groups present a one-slide summary and field questions.	VirtualBox 7.x, Ubuntu 22.04 LTS ISO, CompTIA Linux+ Study Guide (Sybex), projector, student VMs	Exit ticket: students answer five short-answer questions identifying kernel version commands, distro differences, and shell types; 80% correct to pass.
2	Filesystem Navigation and Basic Commands	14	lab	Students will navigate the Linux directory hierarchy and perform file and directory operations using core commands without reference aids.	Timed command drill: students complete a structured worksheet requiring them to use pwd, ls, cd, mkdir, rmdir, cp, mv, rm, and find to reproduce a specified directory tree in under 20 minutes. Pair challenge: given a scrambled project directory, partners use find and ls flags to identify misplaced files and move them to the correct locations, documenting each command in a lab log. Reflection write-up: students describe the Filesystem Hierarchy Standard (FHS) directories (/etc, /var, /home, /usr, /tmp) and explain what a web developer is likely to store in each.	Student Linux VMs, FHS reference (man hier), lab worksheet PDF, lab log template	Instructor observes directory tree reproduction; all required files in correct locations and all commands logged correctly — 80% of steps completed correctly to pass.
3	Users, Groups, and File Permissions	16	lab	Students will create users and groups, assign appropriate file permissions using symbolic and octal notation, and apply the least-privilege principle to a sample web project directory.	Instructor demo: create a 'webteam' group, add two users, set a shared /var/www/webteam directory with group ownership and sticky bit; students replicate step-by-step on their own VMs. Permission audit exercise: students receive a directory with intentionally over-permissive files (world-writable configs, executable data files) and must identify and correct each issue using chmod and chown, recording before/after output from 'ls -l'. Scenario debrief: class reviews OWASP guidance on insecure file permissions and maps each chmod correction made during the audit to a security rationale.	Student VMs, chmod/chown man pages, OWASP File Permission guidance (owasp.org), lab log	Instructor inspects final permission state of each VM using a checklist; all nine checklist items (correct owner, group, mode for three files) must be correct — pass requires 8/9.
4	Text Processing: grep, sed, awk, and Pipelines	14	lab	Students will extract, transform, and summarize data from log and config files using grep, sed, awk, sort, uniq, and pipes.	Guided practice: instructor walks through parsing an Apache access.log sample — students use grep to filter 404 errors, pipe to awk to extract IP addresses, sort and uniq -c to count frequency, then sort -rn to rank by count. Independent lab: students are given a 500-line application log and a task sheet requiring six specific queries (e.g., count POST requests, extract timestamps for errors, replace deprecated config key with new key using sed); results are saved to an output file. Peer review: partners exchange output files and verify results by running the same queries independently, resolving discrepancies together and noting them in their lab logs.	Sample Apache access.log and application log files (provided), grep/sed/awk man pages, lab task sheet, student VMs	Instructor compares student output files to answer key; 5 of 6 queries must produce correct output to pass.
5	Bash Scripting Fundamentals	18	lab	Students will write Bash scripts using variables, conditionals, loops, and functions to automate a defined development task.	Worked example: instructor live-codes a backup script that accepts a source directory argument, checks whether it exists, creates a timestamped tarball in /tmp, and prints a success or error message; students type along and run at each step. Individual scripting lab: students write a script named 'deploy_check.sh' that verifies three preconditions before a mock deployment (git status is clean, a config file exists, a port is not already in use using 'ss -tuln'); script exits with a descriptive error if any check fails. Script review session: each student reads another student's script aloud, explains what each section does, and suggests one improvement; improvements are implemented and re-tested.	Student VMs, Bash reference manual (gnu.org/software/bash/manual), lab instruction sheet, VS Code with Bash IDE extension or vim	Instructor runs deploy_check.sh against three pre-set scenarios (pass, fail on config, fail on port); script must handle all three correctly with clear exit messages — pass requires 3/3 scenarios correct.
6	Advanced Bash: Input Validation, Error Handling, and Scheduling	14	lab	Students will add input validation, exit codes, and cron scheduling to Bash scripts and verify correct behavior under failure conditions.	Instructor demo: extend the backup script from the previous lesson with set -euo pipefail, a usage() function triggered by missing arguments, and logging of errors to /var/log/backup.log. Lab: students modify their deploy_check.sh to log all outcomes with timestamps to a log file, return appropriate exit codes (0 for success, non-zero for each failure type), and schedule the script to run every weekday at 7 a.m. using crontab -e. Failure simulation: instructor or lab partner deliberately triggers each failure condition (missing file, occupied port) and students confirm that the log file and exit code reflect the error correctly.	Student VMs, crontab man page, Bash manual (set built-in section), previous deploy_check.sh script	Instructor reviews crontab entry and runs script under each failure scenario; log entries and exit codes must be correct for all three scenarios — pass requires 3/3.
7	Package Management and Software Installation	12	demo	Students will install, update, remove, and audit software packages using apt and dpkg on Ubuntu, and explain the role of repositories and package pinning.	Instructor-led walkthrough: demonstrate adding the NodeSource PPA, installing a specific Node.js version, holding the package to prevent unintended upgrades with apt-mark hold, and verifying installation with 'node -v' and 'dpkg -l'. Guided lab: students install a LAMP-like stack (Apache2, PHP, MariaDB) using apt, enable the services with systemctl, verify each is active, then remove MariaDB cleanly with apt purge and confirm no residual config files remain. Group discussion: instructor presents a scenario where a production server auto-updated a dependency and broke the app; students identify which apt and dpkg commands would have helped prevent or diagnose the issue.	Student VMs with internet access, Ubuntu package repositories, NodeSource installation docs, apt/dpkg man pages	Instructor checks that Apache and PHP are active, the pinned Node version matches the target, and MariaDB is fully removed — all three verified to pass.
8	System Services and Process Management	12	lab	Students will manage Linux services with systemctl, monitor and control processes with ps, top, kill, and nice, and configure a simple custom systemd unit file.	Lab exercise: students start, stop, enable, disable, and check the status of Apache2 using systemctl; they record the difference between 'start' and 'enable' in their lab logs with a concrete example. Process control drill: instructor launches a CPU-intensive background process with a low nice value; students identify it using top, renice it to a higher value, and finally kill it gracefully with SIGTERM then confirm it is gone. Custom unit file: students create a systemd service unit file that runs their deploy_check.sh script on boot, place it in /etc/systemd/system/, reload the daemon, enable the service, and verify it appears in 'systemctl list-units'.	Student VMs, systemd man pages (systemctl, systemd.service), lab instruction sheet	Instructor verifies that the custom unit file loads without errors (systemctl status shows 'loaded'), the service is enabled, and the process control drill steps are documented correctly in the lab log — pass requires all three items confirmed.
9	Linux Networking for Developers	14	lab	Students will inspect network interfaces, test connectivity, resolve hostnames, examine open ports, and apply basic ufw firewall rules on a Linux server.	Guided practice: students use ip addr, ip route, ss -tuln, ping, traceroute, dig, and curl to map the network configuration of their VM and document each command's output in a structured worksheet. Firewall lab: students configure ufw to allow SSH and HTTP (ports 22 and 80), deny all other inbound traffic by default, verify the rule set with 'ufw status verbose', and test that a curl request to the Apache server succeeds while a connection to an unconfigured port is refused. Troubleshooting scenario: instructor provides a VM with a broken web server (wrong port bound, ufw rule missing); students diagnose the issue using ss and ufw status, correct it, and document the root cause and fix in their lab log.	Student VMs, iproute2 and net-tools packages, ufw man page, curl, troubleshooting scenario VM snapshot	Instructor tests connectivity to Apache on port 80 (must succeed) and to a blocked port (must fail); troubleshooting root cause must be correctly identified in the lab log — pass requires both connectivity outcomes and a correct written root cause.
10	SSH, Remote Access, and Key-Based Authentication	14	lab	Students will generate SSH key pairs, configure key-based login to a remote Linux host, harden the SSH daemon configuration, and use SCP and rsync for secure file transfer.	Key generation lab: students run 'ssh-keygen -t ed25519' with a passphrase, copy the public key to a partner's VM using ssh-copy-id, and confirm passwordless login works before and after disabling password authentication in sshd_config. SSH hardening walkthrough: instructor demonstrates setting 'PermitRootLogin no', 'PasswordAuthentication no', and a custom port in /etc/ssh/sshd_config; students implement each change, reload sshd, and verify the daemon is still reachable. File transfer exercise: students use scp to push a project archive to the remote VM and rsync with --checksum to synchronize a local directory, then compare sizes with 'du -sh' to confirm accuracy.	Pairs of student VMs on the same LAN, OpenSSH man pages, sshd_config reference, rsync man page	Instructor attempts password login to each student's VM (must be refused) and key-based login (must succeed); rsync output must show zero files skipped — pass requires both outcomes confirmed.
11	Shell Environment, Variables, and Startup Files	14	lab	Students will configure the shell environment by setting and exporting variables, modifying PATH, and customizing .bashrc and .bash_profile to support a reproducible development workspace.	Instructor demo: show the difference between shell variables and environment variables using 'env', 'set', and 'export'; demonstrate how a child process inherits only exported variables by running a sub-shell and echoing both types. Workspace configuration lab: students add a custom ~/bin directory to PATH in .bashrc, create an alias for a frequently used git command, set a PROJECT_ROOT environment variable, and confirm changes persist across new terminal sessions. Dotfile portability exercise: students write a setup.sh script that installs their .bashrc customizations on a fresh VM (simulated by a clean-user account), run it, and verify the environment is correctly reproduced.	Student VMs, Bash manual (startup files section), dotfile lab instruction sheet	Instructor opens a new terminal on each student VM and verifies PATH contains ~/bin, the alias works, and PROJECT_ROOT is set — all three must be confirmed to pass.
12	Capstone Integration Lab: Linux Server Provisioning Script	18	lab	Students will write a fully documented Bash provisioning script that configures a fresh Ubuntu VM as a ready-to-use web development server, incorporating skills from all prior lessons.	Project planning: students draft a written specification listing the exact tasks their script must perform (user creation, package installation, firewall rules, Apache configuration, SSH hardening, cron job, service enablement) and have it reviewed by the instructor before coding. Script development: students build 'provision.sh' incrementally across multiple work sessions, testing each section on a clean VM snapshot; they use set -euo pipefail, inline comments, and a log file; instructor circulates and provides formative feedback. Demo and defense: each student runs provision.sh on a fresh VM in front of the class, narrates what each section does, answers two instructor questions about design decisions, and submits the final script with a one-page README.	Student VMs, all prior lesson materials, provision.sh rubric, README template	Instructor runs provision.sh on a clean VM using the grading rubric; all required configurations must be present and functional, script must exit 0, README must explain all major sections — pass requires 85% of rubric points.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Linux+ Domain Knowledge Exam	Written exam	25%	75% (30/40 questions correct)	A 40-question written exam covering CompTIA Linux+ domain areas: system management, security, scripting/containers/automation, and troubleshooting, drawn from lesson content. Questions use multiple-choice and scenario-based formats mirroring the actual exam style. Standard met · Safety · Time · Quality/finish · Documentation
Bash Scripting Skills Demonstration	Skills demonstration	45%	Instructor rubric score of 80% or higher across all criteria	Students receive an unseen prompt 30 minutes before the demo and must produce a working Bash script that installs a package, creates a user, sets file permissions, and schedules a cron job; they then explain each section to the instructor and answer two follow-up questions. Standard met · Safety · Time · Quality/finish · Documentation
Lab Log Portfolio	Log	15%	Entries for all 12 lessons present and each entry scores at least 3/4 on the completeness rubric	Students submit their cumulative lab log containing command records, before/after screenshots or terminal output, written reflections, and correction notes for every lesson lab; the log is reviewed for accuracy, completeness, and evidence of troubleshooting. Standard met · Safety · Time · Quality/finish · Documentation
Safe System Administration Safety Check	Safety audit	15%	All five critical safety behaviors observed without prompting; no safety failures permitted	Instructor uses a structured observation checklist during the capstone lab to verify that students consistently apply least-privilege (no unnecessary sudo), SSH key authentication (no plaintext passwords), correct file permissions on sensitive files, no world-writable web directories, and that they do not run unknown scripts as root without review. Standard met · Safety · Time · Quality/finish · Documentation

TEC-WEB46-07 Trade course

Deployment: Servers, CI/CD, and Cloud Publishing

170 hr · ~~$2,040~~ COMPLIMENTARY

Students configure Linux servers, build automated CI/CD pipelines, and deploy web applications to cloud hosting environments using industry-standard tools. The course bridges local development with production operations, covering DNS, TLS, environment security, containerization, and monitoring. Lessons map to CompTIA Linux+ domain objectives and reinforce CompTIA ITF+ infrastructure and security concepts.

Outcomes

Configure and harden a Linux web server (Apache or Nginx) to serve a web application over HTTPS with a valid TLS certificate.
Build a functional CI/CD pipeline using a version-control-triggered workflow that automatically tests and deploys application code.
Deploy a containerized application using Docker and manage container lifecycle commands from the command line.
Implement environment variable management and secrets handling that keeps credentials out of source code and version control.
Set up basic application monitoring and log review procedures to detect errors and confirm uptime in a production environment.
Execute a production deployment checklist, including rollback procedure, and document each step in a professional deployment runbook.

Course text

How the course runs. 12 blocks: Production vs. Development: The Deployment Mindset; Cloud Hosting Platforms and VPS Provisioning; Linux Server Configuration and Hardening; Web Server Installation and Virtual Hosts; DNS Configuration and TLS with Let's Encrypt; Environment Variables and Secrets Management; Introduction to Docker and Containerization; CI/CD Concepts and GitHub Actions Fundamentals; Building a CI/CD Pipeline with GitHub Actions; Application Monitoring, Logs, and Uptime Checks; Rollback Strategies and Deployment Safety; Capstone Deployment Sprint: Full Production Release.

What competent looks like. Configure and harden a Linux web server (Apache or Nginx) to serve a web application over HTTPS with a valid TLS certificate. Build a functional CI/CD pipeline using a version-control-triggered workflow that automatically tests and deploys application code. Deploy a containerized application using Docker and manage container lifecycle commands from the command line. Implement environment variable management and secrets handling that keeps credentials out of source code and version control. Set up basic application monitoring and log review procedures to detect errors and confirm uptime in a production environment. Execute a production deployment checklist, including rollback procedure, and document each step in a professional deployment runbook.

Lessons · 12 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Production vs. Development: The Deployment Mindset	10	theory	Students distinguish the architectural and operational differences between development and production environments and list the key risks addressed at each deployment stage.	Annotate a layered architecture diagram labeling client, CDN, load balancer, web server, application server, and database tiers. Read a post-mortem report from a public production outage (e.g., a published GitHub incident report) and identify which deployment safeguard was missing. Complete a vocabulary matching quiz covering terms: environment parity, idempotency, rollback, zero-downtime deployment, and uptime SLA.	Whiteboard/projector, architecture diagram handout, published incident post-mortem document, CompTIA ITF+ study guide (infrastructure chapter), student notebooks	Students correctly label all seven tiers on a blank architecture diagram and answer at least 8 of 10 vocabulary quiz items correctly (80% pass mark).
2	Cloud Hosting Platforms and VPS Provisioning	14	lab	Students provision a virtual private server (VPS) on a cloud platform, assign SSH key authentication, and verify remote access from their local machine.	Create a VPS instance on a cloud provider (such as DigitalOcean, Linode/Akamai, or AWS Lightsail) using the provider's web console, selecting an Ubuntu LTS image. Generate an Ed25519 SSH key pair locally, upload the public key during provisioning, and log in to the server without a password. Document the instance's IP address, region, plan tier, and monthly cost estimate in a lab log entry following the program's standard log template.	Student laptops, cloud provider account (instructor-provided or free-tier), OpenSSH client, lab log template, cloud provider documentation	Instructor verifies live SSH login to the student's VPS using only key authentication; lab log entry is complete and accurate. Both required to pass.
3	Linux Server Configuration and Hardening	16	lab	Students apply baseline Linux server hardening steps—including disabling root SSH login, configuring UFW firewall rules, and enabling automatic security updates—on their provisioned VPS.	Edit /etc/ssh/sshd_config to set PermitRootLogin no and PasswordAuthentication no, then restart the SSH service and verify the settings take effect. Configure UFW to allow ports 22, 80, and 443 only, enable the firewall, and run ufw status verbose to confirm the rule set. Enable unattended-upgrades on the Ubuntu server, review /etc/apt/apt.conf.d/50unattended-upgrades, and document the configuration in the lab log.	Student VPS from Lesson 2, OpenSSH client, UFW man page, Ubuntu Server documentation, CompTIA Linux+ study guide (security domain), lab log	Instructor runs a remote port scan (nmap) against the student's VPS and reviews sshd_config live; root login and password auth must be disabled and only approved ports open. Lab log entry graded with rubric, 80% required.
4	Web Server Installation and Virtual Hosts	14	lab	Students install Nginx on their VPS, configure a server block (virtual host) for a test domain, and serve a static HTML page confirming the server responds on port 80.	Install Nginx using apt, enable and start the service with systemctl, and verify it is running using systemctl status nginx. Create an Nginx server block configuration file in /etc/nginx/sites-available/ pointing to a document root directory, then symlink it to sites-enabled and reload Nginx. Upload a static index.html to the document root using scp and confirm the page loads in a browser by navigating to the server's IP address.	Student VPS, Nginx official documentation, scp or rsync, browser, lab log	Instructor loads the student's IP in a browser and confirms the correct static page renders; Nginx config passes nginx -t without errors. Both required.
5	DNS Configuration and TLS with Let's Encrypt	14	lab	Students point a domain name to their VPS using DNS A records and obtain and install a free TLS certificate with Certbot so the site is accessible over HTTPS.	Log in to a DNS registrar (instructor-provided test domain or student-owned domain) and create an A record pointing the hostname to the VPS public IP address; verify propagation using dig or nslookup. Install Certbot and the Nginx plugin, run certbot --nginx to obtain a certificate for the domain, and confirm Certbot rewrites the Nginx config to redirect HTTP to HTTPS. View the certificate details in a browser, noting the issuer (Let's Encrypt), validity period, and renewal date, and record findings in the lab log.	Student VPS with Nginx, registered domain name or subdomain, Certbot documentation (certbot.eff.org), dig utility, browser, lab log	Instructor navigates to the student's HTTPS URL and confirms a valid, browser-trusted certificate is present with no mixed-content warnings; lab log entry complete. 80% rubric score required.
6	Environment Variables and Secrets Management	12	theory	Students explain the principle of keeping secrets out of source code and configure application environment variables using a .env file and a process-level method suitable for production.	Review a sample repository where a database password was accidentally committed to Git history; use git log and git show to locate the leak and discuss remediation steps as a class. Create a .env file for a sample Python Flask application, add it to .gitignore, and load variables in the app using python-dotenv; demonstrate that git status no longer tracks the file. Research and present a two-minute verbal summary of one additional secrets management approach (e.g., server-side environment variables set in the cloud console, or a secrets manager service) and record findings in student notes.	Sample Git repository with intentional credential leak, Python Flask sample app, python-dotenv package, .gitignore reference, student laptops, student notebooks	Students demonstrate that their Flask app runs using .env variables and that .env does not appear in git status; instructor confirms .gitignore entry exists. Written summary graded pass/fail.
7	Introduction to Docker and Containerization	16	lab	Students write a Dockerfile for a simple web application, build a Docker image, run the container locally, and describe how containerization improves environment consistency.	Install Docker Engine on the VPS (or a local machine), run the official hello-world container, and review the output explaining what happened at each step. Write a Dockerfile for a provided Python Flask or PHP application, including base image selection, working directory, dependency installation via pip or composer, and CMD instruction; build the image with docker build. Run the container with docker run mapping an external port to the container port, verify the app responds in a browser or with curl, and record image size and run command in the lab log.	Student laptops or VPS, Docker Engine, provided sample web application code, Dockerfile reference documentation (docs.docker.com), lab log	Instructor inspects student's Dockerfile for correct syntax and runs docker build without errors; container must respond correctly on the mapped port. Lab log entry required. Both components must pass.
8	CI/CD Concepts and GitHub Actions Fundamentals	12	theory	Students define continuous integration and continuous deployment, identify the stages of a CI/CD pipeline, and read and explain a provided GitHub Actions workflow YAML file.	Draw a CI/CD pipeline flowchart labeling stages: code push, trigger, build, automated tests, deploy to staging, deploy to production, and rollback path. Read a provided GitHub Actions workflow file (.github/workflows/deploy.yml) line by line as a class, identifying the on trigger, jobs, steps, uses actions, and run commands. Answer a guided worksheet with 10 short-answer questions about the workflow file, including what event triggers the pipeline, which runner OS is used, and what happens if a step fails.	Whiteboard, sample GitHub Actions YAML file, GitHub Actions documentation (docs.github.com/actions), worksheet, student notebooks	Worksheet scored; students must answer at least 8 of 10 items correctly (80%) and their pipeline flowchart must include all six labeled stages.
9	Building a CI/CD Pipeline with GitHub Actions	18	lab	Students create a GitHub Actions workflow that automatically runs linting and unit tests on push and deploys a passing build to their VPS via SSH on merge to the main branch.	Fork or clone a provided sample application repository, add a GitHub Actions workflow file that runs a linter (flake8 for Python or eslint for JS) and at least one automated test on every push to any branch. Add a deployment job to the workflow that uses an SSH action (such as appleboy/ssh-action) with the VPS private key stored as a GitHub Actions secret, pulling the latest code and restarting the server process on successful merge to main. Intentionally break a test in the code, push to a branch, and confirm the pipeline fails and does not deploy; fix the code, push again, and confirm the pipeline passes and deploys. Document both runs in the lab log with screenshots.	Student GitHub account, student VPS, sample application repository, GitHub Actions secrets configuration, GitHub Actions documentation, lab log	Instructor reviews GitHub Actions run history: a failed run (broken test) must show no deployment step completing, and a passing run must show successful deployment. Lab log with screenshots required. Both required to pass.
10	Application Monitoring, Logs, and Uptime Checks	12	demo	Students configure basic server and application monitoring—including log file review with journalctl, Nginx access/error log tailing, and a free uptime check—and respond to a simulated service failure.	Use journalctl -u nginx --since today and tail -f /var/log/nginx/access.log to observe live traffic; instructor generates 404 and 500 errors and students identify them in real time. Register the site with a free uptime monitoring service (such as UptimeRobot free tier) and configure an email alert; instructor stops the Nginx service to trigger a downtime alert, then students restart it. Write a brief incident response note (who, what, when, how resolved) based on the simulated outage, following a provided incident report template.	Student VPS, Nginx, journalctl, UptimeRobot free account, incident report template, student notebooks	Students correctly identify instructor-injected errors in the log within 3 minutes and restart the downed service independently; incident report is complete and submitted. Both required.
11	Rollback Strategies and Deployment Safety	14	practice	Students execute a deployment rollback using Git to revert a bad release on their VPS and document the procedure in a professional deployment runbook.	Instructor deploys a deliberately broken version of an application to the student's VPS by pushing a bad commit; students must identify the failure via logs and roll back to the previous release using git checkout or git revert followed by a server restart. As a class, build a reusable deployment runbook template covering: pre-deployment checklist, deploy steps, smoke test steps, rollback trigger criteria, and rollback procedure. Each student completes their own runbook for their VPS application, including specific commands for their stack, and peer-reviews a classmate's runbook against a provided rubric.	Student VPS, Git, runbook template, peer review rubric, student notebooks	Instructor confirms the student successfully rolled back the broken release and the application serves correct content within 10 minutes; runbook peer review score must be 80% or above.
12	Capstone Deployment Sprint: Full Production Release	18	lab	Students independently deploy a provided multi-file web application to their hardened VPS with HTTPS, a working CI/CD pipeline, secrets management, monitoring, and a completed deployment runbook.	Receive the sprint application package (a Python Flask or PHP app with a database connection); plan the deployment by completing a written pre-deployment checklist covering server state, DNS, TLS, environment variables, and pipeline configuration. Execute the full deployment end-to-end: push code to GitHub, verify CI/CD pipeline runs tests and deploys to VPS, confirm HTTPS with valid certificate, and confirm environment variables are not in source control. Present the live deployment to the instructor in a 10-minute walkthrough, demonstrating the pipeline run, HTTPS URL, log monitoring, and rollback capability; submit the runbook as a graded deliverable.	Sprint application package, student VPS, GitHub, Docker (optional), all tools from Lessons 1-11, runbook template, grading rubric	Scored against a rubric with six criteria (server hardening, HTTPS, CI/CD pipeline function, secrets management, monitoring, runbook quality); students must achieve 80% overall with no criterion scoring below 60%.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Deployment Concepts Knowledge Exam	Written exam	25%	80% correct (40 of 50 items)	A 50-item multiple-choice and short-answer exam covering deployment architecture tiers, DNS and TLS concepts, CI/CD pipeline stages, Docker fundamentals, environment variable security, and Linux server management; mapped to CompTIA Linux+ infrastructure and security domain objectives and CompTIA ITF+ infrastructure concepts. Standard met · Safety · Time · Quality/finish · Documentation
Live Deployment Skills Demonstration	Skills demonstration	45%	Score of 80% or above on a six-criterion rubric; no criterion below 60%	Students perform the Lesson 12 capstone deployment sprint under instructor observation, demonstrating a hardened HTTPS server, functional CI/CD pipeline, secrets management, uptime monitoring, and rollback capability, then defend their runbook in a 10-minute walkthrough. Standard met · Safety · Time · Quality/finish · Documentation
Deployment Lab Log Portfolio	Log	15%	At least 9 of 11 lab log entries complete and accurate; overall rubric score 80% or above	Students submit their cumulative lab log containing entries from every lab and practice lesson (Lessons 2 through 12), each documenting commands used, outputs observed, problems encountered, and solutions applied; graded for completeness, accuracy, and professional clarity. Standard met · Safety · Time · Quality/finish · Documentation
Server Security and Safe Practices Check	Safety audit	15%	Pass/fail — all six checklist items must be met with no exceptions	Instructor audits each student's live VPS against a six-item security checklist: root SSH login disabled, password authentication disabled, UFW active with only approved ports open, .env or secrets not committed to the repository, TLS certificate valid and HTTPS enforced, and no world-writable files in the document root; any single failure requires remediation before the course is marked complete. Standard met · Safety · Time · Quality/finish · Documentation

TEC-WEB46-08 Capstone

Capstone Project: Full-Stack Web Application Build, Documentation, and Defense

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

Students design, build, test, document, and publicly defend an original full-stack web application that integrates HTML/CSS/JavaScript, a Python or PHP backend, a PostgreSQL database, version control via Git, and Linux-based deployment. The capstone demonstrates mastery of every technical and professional skill developed across the program, culminating in a live project defense before an industry review panel. Lessons map to CompTIA ITF+ (IT concepts, software development lifecycle, security basics), CompTIA Linux+ (shell scripting, file permissions, service management, deployment), and PCEP Python (program logic, data structures, functions, error handling) where applicable.

Outcomes

Design and implement a complete full-stack web application with a relational database backend, authenticated user flows, and a responsive frontend, applying the software development lifecycle from requirements through deployment.
Write and maintain a Git repository with a branching strategy, meaningful commit history, and a README that meets industry documentation standards.
Deploy the finished application to a Linux server or cloud platform using shell scripts and a process manager, configuring firewall rules and environment variables for a production environment.
Produce a professional project portfolio package including a software requirements specification, entity-relationship diagram, API documentation, and a user guide.
Identify and remediate at least three common web security vulnerabilities (SQL injection, cross-site scripting, broken authentication) in their own codebase, citing OWASP guidelines.
Present and defend technical design decisions, trade-offs, and lessons learned to a panel of instructors and industry reviewers, responding accurately to questions about code, architecture, and professional practice.

Course text

How the course runs. 4 blocks: Project Planning, Requirements, and Architecture Design; Iterative Development: Backend, Database, and API Build; Frontend Integration, Linux Deployment, and Security Hardening; Documentation Completion, Portfolio Assembly, and Project Defense.

What competent looks like. Design and implement a complete full-stack web application with a relational database backend, authenticated user flows, and a responsive frontend, applying the software development lifecycle from requirements through deployment. Write and maintain a Git repository with a branching strategy, meaningful commit history, and a README that meets industry documentation standards. Deploy the finished application to a Linux server or cloud platform using shell scripts and a process manager, configuring firewall rules and environment variables for a production environment. Produce a professional project portfolio package including a software requirements specification, entity-relationship diagram, API documentation, and a user guide. Identify and remediate at least three common web security vulnerabilities (SQL injection, cross-site scripting, broken authentication) in their own codebase, citing OWASP guidelines. Present and defend technical design decisions, trade-offs, and lessons learned to a panel of instructors and industry reviewers, responding accurately to questions about code, architecture, and professional practice.

Lessons · 4 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Project Planning, Requirements, and Architecture Design	40	theory	Given a project idea, the student will produce a complete software requirements specification (SRS), a system architecture diagram, an entity-relationship diagram, and a Git repository initialized with a branching strategy before any code is written.	Draft a one-page project proposal including target users, core features, and out-of-scope items; receive peer and instructor sign-off using a structured checklist before advancing. Build an entity-relationship diagram in draw.io (or equivalent) covering all planned database tables, primary/foreign keys, and relationships, then walk a classmate through it in a five-minute verbal review. Initialize a GitHub (or GitLab) repository, create main and develop branches, write a README skeleton following the Make a README guide, and commit the SRS and ER diagram as the project's first documented artifacts.	Draw.io or Lucidchart (free tier), GitHub or GitLab account, IEEE 830 SRS template (adapted), OWASP Top Ten reference (owasp.org), instructor-provided project rubric, Google Docs or Markdown editor	Instructor reviews SRS for completeness (all required sections present), ER diagram for referential integrity, and repository for correct branch structure and initial commit; all three items must be marked Satisfactory on the rubric to proceed — any Unsatisfactory item requires revision within two class days.
2	Iterative Development: Backend, Database, and API Build	80	lab	The student will implement the application's backend in Python (Flask or Django) or PHP, wire it to a PostgreSQL database using parameterized queries, and expose a documented REST API — all committed through pull requests on the develop branch — while eliminating SQL injection and XSS vulnerabilities confirmed by instructor code review.	Complete three one-week sprints, each ending with a working, tested feature merged via pull request; sprint 1 covers data models and CRUD routes, sprint 2 covers user authentication (hashed passwords, session or JWT), and sprint 3 covers any remaining core features and input validation. Write a Python or PHP unit test suite covering at least 70 percent of custom functions and all database interaction functions; run tests in a CI step (GitHub Actions or GitLab CI) and fix any failures before merging — maps directly to PCEP Python exam area: functions, error handling, and program logic. Conduct a peer security audit using the OWASP Top Ten checklist: the partner attempts SQL injection against login and search endpoints and inspects HTML output for unescaped user data; findings are logged as GitHub Issues and resolved before the sprint closes.	Python 3 (Flask or Django) or PHP 8, PostgreSQL 15, psycopg2 or PDO library, Postman or curl for API testing, pytest or PHPUnit, GitHub Actions YAML reference, OWASP Top Ten (owasp.org), instructor sprint review form, VS Code with ESLint and Pylint plugins	Each sprint pull request must pass automated CI tests (green build) and instructor code review scoring 70 percent or higher on the sprint rubric (logic correctness, security, code style, test coverage); a sprint scoring below 70 percent is revised and re-reviewed within three class days before the next sprint begins.
3	Frontend Integration, Linux Deployment, and Security Hardening	56	lab	The student will integrate a responsive HTML/CSS/JavaScript frontend with the backend API, deploy the complete application to a Linux server (virtual machine or cloud instance) using a shell script and a process manager, configure UFW firewall rules and HTTPS, and verify the live deployment passes a functional and security checklist — mapping to CompTIA Linux+ exam areas: file permissions, service management, firewall configuration, and shell scripting.	Write a Bash deployment script (deploy.sh) that pulls the latest code from the main branch, installs dependencies, runs database migrations, restarts the application process (systemd service or Gunicorn/Nginx), and logs the result to /var/log/deploy.log with a timestamp — instructor reviews the script for correct shebang, set -e error handling, and restricted file permissions (chmod 750). Configure UFW to allow only ports 22, 80, and 443; obtain and install a TLS certificate using Certbot (Let's Encrypt) or a self-signed certificate for lab environments; verify HTTPS redirect is enforced using curl -I and correct any misconfiguration before sign-off. Run the completed live application through a functional test checklist (all CRUD operations, authentication, and error pages) and a manual OWASP checklist; document every finding in a one-page security hardening report and commit it to the repository under /docs.	Ubuntu Server 22.04 LTS (VM via VirtualBox or a cloud provider free tier), Nginx, Gunicorn or PHP-FPM, systemd, UFW, Certbot (Let's Encrypt), Bash scripting reference (GNU Bash manual), CompTIA Linux+ objectives guide, instructor deployment checklist, VS Code Remote-SSH extension	Instructor visits the live URL and runs the functional and security checklists; deployment earns a pass when all critical checklist items are marked Pass, the site loads over HTTPS, and the deploy.sh script runs without error on a clean server — any critical failure requires remediation and re-check within two class days.
4	Documentation Completion, Portfolio Assembly, and Project Defense	40	practice	The student will finalize all project documentation (README, API docs, user guide, reflection report), assemble a professional digital portfolio entry, and deliver a 20-minute live defense presentation with a 10-minute question-and-answer session before a panel of at least one instructor and one industry reviewer.	Complete the repository README to include project overview, technology stack, setup and deployment instructions, known limitations, and a link to the live demo; write API documentation in Markdown or Swagger/OpenAPI format covering every endpoint with request/response examples — reviewed by a peer for clarity before final submission. Record a three-to-five-minute screencast walkthrough of the live application demonstrating all major features; add the recording link, the GitHub repository URL, and a one-paragraph project summary to the student's professional portfolio (personal website or platform such as GitHub Pages established in earlier coursework). Deliver the project defense before the review panel using a slide deck of ten to fifteen slides covering problem statement, architecture, key technical decisions, security measures, test results, deployment process, and lessons learned; respond to panel questions for ten minutes; self-assess using the provided defense rubric immediately after the session.	Slide presentation tool (Google Slides, LibreOffice Impress, or PowerPoint), Loom or OBS Studio for screencast, Swagger Editor (editor.swagger.io) or Markdown, GitHub Pages or personal portfolio site, instructor and industry-reviewer panel evaluation rubric, program style guide for documentation	The defense is scored by the full panel on the defense rubric (technical accuracy, completeness of documentation, clarity of communication, ability to answer questions); a passing defense requires an average panel score of 70 percent or higher across all rubric domains — a student scoring below 70 percent completes targeted remediation identified by the panel and repeats the defense within ten business days.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Capstone Project: Live Full-Stack Application	Project	60%	70 percent or higher on the cumulative project rubric, with no Critical deficiencies outstanding (all security and deployment checklist items resolved)	The deployed, publicly accessible application is evaluated against the project rubric covering functionality (all SRS features working), code quality (linting, test coverage at or above 70 percent, no hard-coded credentials), database design (normalized schema, parameterized queries), security hardening (HTTPS, firewall, OWASP checklist passed), and Git history (meaningful commit messages, pull-request workflow followed throughout). Scores from all three sprint reviews and the final deployment check are averaged to produce the project grade. Meets specification · Within estimate · Workmanship · Safety · Documentation
Professional Portfolio and Documentation Package	Portfolio	20%	70 percent or higher on the documentation rubric, with all four required documents present and complete	The portfolio package — comprising the finalized README, API documentation, user guide, security hardening report, and the project's portfolio entry (screencast plus written summary) — is evaluated for technical accuracy, completeness, professional formatting, and clarity. The panel confirms that a developer unfamiliar with the project could set up, run, and use the application using only the submitted documentation. Completeness · Organization · Evidence quality
Project Defense: Oral Presentation and Technical Question-and-Answer	Oral / panel	20%	Average panel score of 70 percent or higher across all rubric domains (technical accuracy, design justification, communication clarity, and responsiveness to questions)	The student presents the project in a 20-minute structured presentation followed by a 10-minute question-and-answer session with the instructor-and-industry-reviewer panel; panelists independently score the defense and reach a consensus pass/fail, with written feedback provided to the student on the same day to support ongoing professional development. Explains decisions · Answers technical questions · Professional communication

TEC-WEB46-09 Externship / clinical

Externship / Worksite Placement

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

Students complete 324 supervised hours at an approved employer site in web or software development, applying skills from all prior courses in a real workplace context. A credentialed industry mentor evaluates professional conduct, technical output, and communication skills using a structured rubric. This course bridges classroom learning and entry-level employment by immersing students in authentic project workflows, team collaboration, and workplace standards.

Outcomes

Perform assigned web or software development tasks—including coding, testing, and version control—under employer supervision with professional-level reliability.
Communicate status updates, blockers, and completed deliverables clearly to supervisors and teammates using workplace tools such as ticketing systems, email, and stand-up meetings.
Apply safe ergonomic and digital-security practices (password hygiene, access-control protocols, clean-desk policy) consistently throughout the placement.
Maintain a detailed daily work log documenting hours, tasks, technologies used, and lessons learned across the full 324-hour placement.
Receive a passing employer evaluation (score of 75 or above on a 100-point rubric) covering technical skill, professionalism, teamwork, and initiative.
Reflect on placement experience to identify at least three measurable professional development goals for the first year of employment.

Course text

How the course runs. 4 blocks: Pre-Placement Orientation and Worksite Readiness; Supervised On-Site Development Work — Phase 1 (Weeks 1–5); Supervised On-Site Development Work — Phase 2 (Weeks 6–12); Externship Reflection, Documentation, and Professional Goal-Setting.

What competent looks like. Perform assigned web or software development tasks—including coding, testing, and version control—under employer supervision with professional-level reliability. Communicate status updates, blockers, and completed deliverables clearly to supervisors and teammates using workplace tools such as ticketing systems, email, and stand-up meetings. Apply safe ergonomic and digital-security practices (password hygiene, access-control protocols, clean-desk policy) consistently throughout the placement. Maintain a detailed daily work log documenting hours, tasks, technologies used, and lessons learned across the full 324-hour placement. Receive a passing employer evaluation (score of 75 or above on a 100-point rubric) covering technical skill, professionalism, teamwork, and initiative. Reflect on placement experience to identify at least three measurable professional development goals for the first year of employment.

Lessons · 4 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	Pre-Placement Orientation and Worksite Readiness	18	theory	Students will demonstrate understanding of employer expectations, workplace safety responsibilities, legal agreements, and professional conduct standards before their first day on site.	Complete a pre-placement checklist covering signed externship agreement, emergency contact form, confidentiality/NDA review, and transport plan; discuss each item with the program coordinator in a small-group session. Role-play three common workplace scenarios—receiving critical feedback, resolving a scheduling conflict, and escalating a technical blocker—then debrief with peers on best-practice responses. Review the employer evaluation rubric line by line, score a sample fictional student's mid-term evaluation, and write a one-page personal readiness statement identifying two areas to watch during placement.	Externship agreement template, employer evaluation rubric (100-point scale), OSHA 10 card (from Course 1), program coordinator's site-approval checklist, sample NDA, role-play scenario cards	Student submits completed pre-placement checklist with all signatures and scores 80% or above on a 20-question written quiz covering professional conduct standards, safety responsibilities, and rubric criteria; coordinator signs off before student may begin on-site hours.
2	Supervised On-Site Development Work — Phase 1 (Weeks 1–5)	108	field	Students will execute assigned development tasks—such as building or maintaining web pages, writing and debugging code, and committing work via version control—under direct mentor supervision during the first phase of placement.	Participate in the employer's standard sprint or project workflow (e.g., daily stand-ups, ticket assignment, code review) and complete at least two assigned tasks per week, logging each task with time spent, technologies used, and outcome in the daily work log. Receive and act on at least one round of code review or supervisor feedback per week; revise the relevant deliverable and document the changes made and the reasoning behind each revision in the work log. Attend at least one team or client meeting per two-week period, take structured notes on decisions made and action items assigned, and share a brief written summary with the program coordinator by the end of each week.	Employer-issued workstation and credentials, student's personal work-log template (digital or paper), version-control system used by employer (e.g., Git/GitHub/GitLab), ticketing or project-management tool used by employer (e.g., Jira, Trello, Asana), secure communication platform used by employer	Coordinator reviews weeks 1–5 work-log entries at the Phase 1 check-in meeting; log must contain entries for every shift with tasks, hours, and technologies documented; mentor completes mid-placement rubric section (technical skill + professionalism sub-scales) and student must score 70 or above on those combined sub-scales to continue to Phase 2.
3	Supervised On-Site Development Work — Phase 2 (Weeks 6–12)	162	field	Students will demonstrate increasing independence by taking on expanded or more complex tasks, contributing to team deliverables, and applying feedback from Phase 1 throughout the second and final phase of placement.	Lead or co-lead at least one discrete feature, bug-fix sprint, or internal tool project from initial ticket through deployment or handoff, documenting the full development cycle (planning, coding, testing, review, deployment) in the work log. Conduct a voluntary mid-Phase-2 self-assessment against the employer rubric, identify the two lowest-scoring areas, and set specific improvement actions in writing; share the self-assessment with the mentor and discuss in a brief one-on-one. Compile a portfolio artifact from Phase 2 work—such as a documented code sample, a tested feature branch, or a technical write-up of a problem solved—that can be added to the student's professional portfolio with employer permission.	Same employer-issued workstation and tools as Phase 1, employer rubric (full 100-point version), self-assessment worksheet, portfolio artifact release/permission form, work-log template (continued)	Coordinator reviews weeks 6–12 work-log entries; all shifts must be documented; mentor completes final employer evaluation rubric (100 points covering technical skill, professionalism, teamwork, communication, and initiative); student must score 75 or above overall to satisfy the externship requirement; coordinator conducts an exit interview with the student and mentor together.
4	Externship Reflection, Documentation, and Professional Goal-Setting	36	practice	Students will synthesize their placement experience into a reflective portfolio entry and a written professional development plan that identifies concrete, measurable career goals for the first year of employment.	Write a 600–900 word structured reflection covering: the three most significant technical skills practiced, the most challenging professional situation encountered and how it was resolved, and how the placement changed or confirmed the student's career direction. Assemble a final work-log summary: consolidate all daily entries into a one-page table showing total hours per technology/task category, and verify the total equals 324 hours; submit to the coordinator for program records. Draft a 12-month professional development plan listing at least three SMART goals (Specific, Measurable, Achievable, Relevant, Time-bound) tied to skills identified as growth areas during the placement, and present the plan in a 10-minute verbal debrief with the program coordinator.	Completed daily work logs, employer evaluation rubric with mentor's scores, reflection prompt worksheet, SMART-goal planning template, student portfolio folder, program coordinator's debrief scoring guide	Coordinator scores the reflection using a 4-point analytic rubric (depth of analysis, use of specific examples, professional language, and clarity); student must score 3 or above on each dimension (12/16 total); the professional development plan must contain at least three fully formed SMART goals and receive coordinator approval; the final work-log summary must confirm 324 documented hours.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Employer Skills Evaluation (Skills Demonstration)	Skills demonstration	70%	Score of 75 or above out of 100 on the employer evaluation rubric, completed and signed by the worksite mentor at the end of the placement.	The worksite mentor evaluates the student on five weighted dimensions—technical skill execution, professional conduct and reliability, teamwork and communication, problem-solving initiative, and adherence to workplace safety and security policies—using the program's standardized 100-point rubric. The completed rubric is reviewed jointly by the mentor and program coordinator in the exit interview, and any dimension scored below 60 must be addressed in the student's professional development plan. Competency · Safety · Attendance · Conduct · Initiative
Daily Work Log and Reflective Portfolio Entry (Lab Log)	Log	30%	All 324 hours documented with no gaps; reflection scores 12 out of 16 on the analytic rubric; professional development plan contains at least three approved SMART goals.	The student submits the consolidated daily work log and the reflective portfolio entry—including the 12-month professional development plan—to the program coordinator at the conclusion of the externship. The coordinator verifies total hours, reviews log quality for specificity and consistency, and scores the reflection and development plan against published criteria; missing hours or a reflection scoring below the passing threshold requires the student to supplement documentation before the externship grade is recorded. Complete · Verified

TEC-WEB46-10 Exam prep

Certification Exam Preparation: ITF+, Linux+, and PCEP Python

90 hr · ~~$900~~ COMPLIMENTARY

This course prepares students to sit and pass the CompTIA ITF+, CompTIA Linux+, and PCEP Python certification exams through structured review of each exam's official objectives, timed practice questions, and full-length mock exams. Lessons are sequenced to reinforce content from earlier courses, close identified knowledge gaps, and build test-taking stamina and strategy. Students complete the program ready to register and sit all three credential exams with confidence.

Outcomes

Correctly answer practice questions across all CompTIA ITF+ exam objective domains at or above the vendor-published passing threshold.
Correctly answer practice questions across all CompTIA Linux+ exam objective domains at or above the vendor-published passing threshold.
Correctly answer practice questions across all PCEP Python exam objective domains at or above the vendor-published passing threshold.
Apply time-management and elimination strategies to complete timed, full-length mock exams within the allotted window.
Identify personal knowledge gaps from diagnostic results and execute a targeted remediation plan before sitting live exams.
Complete and submit exam registration paperwork and understand check-in procedures, acceptable ID, and testing-center policies.

Course text

How the course runs. 4 blocks: ITF+ Objective Review and Diagnostic; Linux+ Objective Review and Diagnostic; PCEP Python Objective Review and Diagnostic; Full Mock Exams, Test Strategy, and Registration Readiness.

What competent looks like. Correctly answer practice questions across all CompTIA ITF+ exam objective domains at or above the vendor-published passing threshold. Correctly answer practice questions across all CompTIA Linux+ exam objective domains at or above the vendor-published passing threshold. Correctly answer practice questions across all PCEP Python exam objective domains at or above the vendor-published passing threshold. Apply time-management and elimination strategies to complete timed, full-length mock exams within the allotted window. Identify personal knowledge gaps from diagnostic results and execute a targeted remediation plan before sitting live exams. Complete and submit exam registration paperwork and understand check-in procedures, acceptable ID, and testing-center policies.

Lessons · 4 blocks

#	Lesson	Hr	Type	Objective	Activities	Materials	Check
1	ITF+ Objective Review and Diagnostic	20	practice	Students will identify their strongest and weakest ITF+ objective domains and correctly answer at least 75% of domain-mapped practice questions by the end of the lesson block.	Complete a 75-question timed diagnostic exam mapped to all ITF+ objective domains (IT concepts, infrastructure, applications, software development, database fundamentals, security); score and analyze results by domain in a personal gap-tracking spreadsheet. Work through instructor-led review sessions for each domain, using the official CompTIA ITF+ Exam Objectives document as a checklist; for each weak domain students re-read relevant notes from Course 1, then answer a 15-question domain quiz. Participate in a peer study-group session where pairs quiz each other on flagged weak areas using flashcard decks (Anki or paper), then debrief with the instructor to resolve any remaining misconceptions.	CompTIA ITF+ official exam objectives (download from CompTIA website), practice question bank (professor-supplied or CertMaster Practice trial), Anki or printed flashcard sets, personal gap-tracking spreadsheet template, Course 1 notes and handouts.	Domain quiz average of 75% or higher across all ITF+ domains; gap-tracking spreadsheet submitted with all domains rated; instructor reviews any domain below 75% for targeted follow-up. Pass mark: 75% on each domain quiz set.
2	Linux+ Objective Review and Diagnostic	25	lab	Students will work through all CompTIA Linux+ exam objective domains—system management, security, scripting and containers, and troubleshooting—achieving at least 75% on domain-mapped practice sets and demonstrating correct command-line execution on performance-based question (PBQ) simulations.	Complete a full-length, timed Linux+ diagnostic exam (multiple-choice and PBQ-style questions) using the official exam objectives as a scoring rubric; enter results into the gap-tracking spreadsheet and rank domains by score. In the classroom Linux lab (virtual machines running a major Linux distribution), reproduce the scenarios behind the PBQ simulations for the two lowest-scoring domains—students type actual commands, capture terminal output as screenshots, and annotate what each command does and why it is tested. Work through a structured cram session using the Linux+ objective checklist: for each objective students write a one-sentence plain-English definition and one CLI example, compiling a personal Linux+ reference sheet; finish with a 40-question timed quiz covering the full objective set.	CompTIA Linux+ official exam objectives, virtual-machine lab environment (VirtualBox or VMware with a current major Linux distribution), SSH client (terminal or PuTTY), instructor-supplied PBQ scenario scripts, practice question bank, students' own Course 6 lab notes.	Domain quiz average of 75% or higher; PBQ simulation screenshots reviewed by instructor for correct command usage and expected output; personal Linux+ reference sheet submitted. Pass mark: 75% aggregate across domain quizzes and instructor sign-off on two PBQ labs.
3	PCEP Python Objective Review and Diagnostic	20	lab	Students will review all PCEP exam syllabus sections—computer programming fundamentals, Python basics, data types, control flow, functions, and Python collections—and score at least 70% on a full PCEP-format practice exam.	Complete a PCEP-format diagnostic exam (multiple-choice, fill-in-the-blank code output, and code-ordering questions); score results and map each missed question to the official PCEP exam syllabus section in the gap-tracking spreadsheet. In a live Python coding lab, work through instructor-written exercises that target the three lowest-scoring syllabus sections; for each exercise students predict output before running code, then explain the discrepancy if any, reinforcing understanding of operator precedence, scope, and list/dict behavior. Build a one-page Python cheat sheet covering syntax rules, built-in functions, and common pitfalls most frequently tested on the PCEP; swap cheat sheets with a partner for peer review, then take a 30-question timed practice set and compare answers.	Python Institute PCEP exam syllabus (download from pythoninstitute.org), Python 3 interpreter (local install or browser-based REPL such as repl.it), instructor-supplied coding exercises mapped to each syllabus section, practice question bank, students' own Course 3 Python notes.	Post-diagnostic practice set score of 70% or higher; coding-lab exercises reviewed by instructor for correct output and appropriate code style; Python cheat sheet submitted. Pass mark: 70% on timed practice set and instructor sign-off on coding exercises.
4	Full Mock Exams, Test Strategy, and Registration Readiness	25	practice	Students will complete one full-length, timed mock exam for each of the three credentials under simulated testing conditions, score at or above the vendor-published passing standard on at least two of the three, and complete exam registration with acceptable ID documentation confirmed.	Sit three back-to-back mock exams in a single exam-simulation day: ITF+ (75 questions, 60-minute window), Linux+ (90 questions plus PBQs, 90-minute window), and PCEP (30 questions, 45-minute window); students follow actual testing-center rules—no notes, phones away, one scratch sheet—then score all three and record results. Complete a structured debrief: for each exam students classify every missed question into one of three categories (never learned, learned but forgot, misread the question), then write a 30-minute targeted remediation session addressing the 'never learned' items using course notes and the official objective documents. Review test-day logistics: instructor walks through the Pearson VUE and Python Institute online testing options, valid government-issued photo ID requirements, what to expect at check-in, and how to register; each student locates their nearest testing center or selects an online-proctored option, confirms voucher or payment method, and prints or screenshots a registration checklist confirming they are ready to schedule.	Full-length mock exams for ITF+, Linux+, and PCEP (instructor-supplied or CertMaster/Python Institute sample exams), printed answer sheets, timer, scratch paper, Pearson VUE website (pearsonvue.com/comptia), Python Institute website (pythoninstitute.org), registration checklist handout, government-issued photo ID (students bring their own for the logistics review).	Mock exam scores recorded and submitted; debrief categorization sheet completed; registration checklist signed off by instructor confirming student has located a testing site and confirmed ID readiness. Pass standard: score at or above the vendor-published passing threshold on at least two of the three mock exams, with a documented remediation plan for any exam scored below threshold.

Assessments

Assessment	Type	Weight	Pass standard	Method & rubric
Three-Credential Full Mock Examination Set	Mock certification exam	100%	Score at or above the vendor-published passing standard on all three mock exams (ITF+, Linux+, PCEP Python) on the first or second attempt within the course; any mock not passed on the first attempt must be retaken after documented remediation and passed before program completion.	Students sit a full-length, timed, closed-note mock exam for each of the three target credentials under simulated testing-center conditions, then complete a written debrief identifying missed-question categories and a remediation plan. Scores and the debrief document are submitted to the instructor as the summative record of exam readiness before the student schedules the live credentialing exams. Score · Time management

Program completion

External credential: CompTIA ITF+; CompTIA Linux+; PCEP Python

Students sit the CompTIA ITF+ and CompTIA Linux+ exams administered by Computing Technology Industry Association (CompTIA), and the PCEP – Certified Entry-Level Python Programmer exam administered by the Python Institute; all exams are taken at authorized testing centers or online through each organization's approved proctoring channels. Pass standard: Credential issued by the body.

Back to Web & Software Development · How the school gets authority to award these credentials