Process over Product Approach 

Implementing Process over Product in Assignments

Shifting to this model involves scaffolding assignments into sequential, graded steps. Here is how it translates to course design:

• Scaffolded Milestones: Break a major project into distinct phases. For example, a research assignment is graded across four parts: a topic proposal with research questions, an annotated bibliography, a rough draft with a peer-review reflection, and finally, the polished paper.

• Reflection and Metacognition: Require students to submit a brief reflection log with their work. Ask them: What design choices did you make? Where did you get stuck, and how did you troubleshoot it?

• Iterative Drafts: Allow students to resubmit work or grade them specifically on how effectively they incorporated feedback from version X to version X+1.

Why This Matters in Modern Higher Education

1. De-incentivizes Academic Dishonesty: When the final “product” is the only thing that carries grade weight, students face immense pressure to outsource the work (whether to GenAI or a peer). When you grade the unique, messy process of creation, cheating becomes much harder and less appealing.

1. Deepens Skill Acquisition: It teaches students how to learn. By forcing them to document their workflow, troubleshooting strategies, and conceptual pivots, you help them build lifelong metacognitive skills.

1. Reduces High-Stakes Anxiety: Breaking a massive assignment into smaller, manageable chunks lowers student anxiety and reduces procrastination, resulting in higher-quality final work.

The following three Information Systems examples illustrate how to shift focus from final deliverables to student learning journeys. You can easily apply these same scaffolding techniques to the assignments in your own context.

Example 1: Full-Stack Web App Project (4 weeklong)

To see how this works in practice, let’s transform a traditional, high-stakes Information Systems project—like building a full-stack web application with a database backend—into a Process over Product framework.

In a traditional course, a student might submit the complete code at the end of the semester for 100% of the project grade. In a Process over Product model, we shift the weight to the design, iterative development, and troubleshooting stages.

Instead of one massive deadline, the project is broken down into four distinct milestones. The final working code is only worth a portion of the total grade; the rest is earned by showing how they built it.

Milestone 1: Architectural Design & Schema: Week 1 (15% of project grade).

Students submit their conceptual blueprint before writing code. This includes a user flow diagram, an Entity-Relationship Diagram (ERD), and a list of AI prompts they used to help brainstorm or refine their database schema.

What you are grading: Conceptual understanding, logical data relationships, and intentional planning.

Milestone 2: The Core API & Mock Data: Week 2 (25% of project grade).

Students build the basic backend routes using mock data. They must submit their code repository along with a short 2-minute screen recording demonstrating that their endpoints work using a tool like Postman.

What you grade: Data modeling logic and architectural reasoning, not just the DDL scripts.

Milestone 2: ETL Pipeline & Data Quality Assurance: Week 2 (25% of grade).

Students write the SQL scripts or utilize cloud orchestration tools to extract, transform, and load (ETL) the data into the cloud warehouse.

The Process Deliverable: Rather than checking if the data is there, students must submit a Data Validation Log. They must write and execute custom SQL unit tests to check for data integrity anomalies (e.g., orphan records, null violations, duplicates) and document how their pipeline handles dirty data.

What you grade: Defensive programming habits and data quality engineering methodologies.

Milestone 3: The Query Optimization Log: Week 3 (30% of grade).

Give students a set of complex business questions requiring multi-table joins, subqueries, and window functions. The catch: the initial dataset is large, and a naive query will run slowly or consume excessive cloud compute credits.

The Process Deliverable: Students submit a Before-and-After Optimization Log for three complex queries. They must include:

• Version 1: Their initial working query.

• The Diagnostics: A screenshot/analysis of the Query Execution Plan (identifying table scans, heavy sorts, or join filters) and performance metrics (execution time, bytes scanned).

• Version 2: The optimized query (e.g., utilizing indexing, partitioning, clustering keys, or CTEs instead of subqueries).

• The Justification: An explanation of why the changes reduced the computation cost or execution time.

What you grade: Ability to read execution plans and apply optimization theory systematically.

Milestone 4: Cloud Cost & Security Governance Reflection: Week 4 (25% of grade).

The final phase looks at cloud infrastructure administration. Students configure Role-Based Access Control (RBAC) security policies and data masking.

The Process Deliverable: A short executive presentation or brief explaining their cloud governance strategy. If they used GenAI to help write complex window functions or optimization scripts, they must submit a “Prompt Audit Trail” detailing how they validated the AI’s logic against their schema constraints.

What you grade: Understanding of cloud economics, data security governance, and technical validation.

Quick-Shift Examples for Weekly Lab Assignments

If you want to apply this to smaller, weekly homework assignments rather than a major project, you can make these quick adjustments:

• The “Explain Plan” Quiz: Instead of a quiz asking for the output of a query, provide a complex query and its graphical Execution Plan. Ask students to circle the biggest performance bottleneck (e.g., a full table scan on a million-row table) and write a one-paragraph solution to fix it.

• The AI Code Review Lab: Give students a functional but horribly un-optimized SQL query generated by a basic LLM prompt. Task the students with auditing the AI’s work, identifying where it failed to utilize best practices (like missing partition filters), and rewriting it for a production environment.

This approach flips the classroom dynamic: the AI becomes the draft-generator, and your students become the highly skilled database engineers who optimize, audit, and govern the infrastructure.

Here is a structured AI Use Log template tailored specifically for database, SQL, and cloud warehousing courses. It balances a quick-glance tabular section for tracking interactions with a narrative text section where students must prove their critical thinking and validation process.

You can drop this directly into your syllabus, project guidelines, or assignment instructions.

Student Assignment Addendum: GenAI Interaction & Validation Log

Instructions: If you utilize Generative AI (such as ChatGPT, Claude, Gemini, or GitHub Copilot) to assist you with data modeling, SQL generation, ETL scripting, or query optimization, you must complete and submit this log alongside your technical files.

The Golden Rule: The AI is your draft junior analyst; you are the system architect. You are graded on your ability to direct, audit, and modify the AI’s output to fit our specific enterprise environment.

Section 1: AI Interaction Ledger (Tabular Format)

Log every major block of code, schema design idea, or optimization strategy you explored with AI.

Section 2: Technical Validation & Code Audit (Text Format)

For any code or architectural choices generated by the AI that you actually implemented in your project, complete the following three narrative sections.

Part A: The Hallucination & Constraint Check

AI tools lack context regarding your specific cloud database cluster size, partitioning strategy, and security constraints.

• Identify at least one mistake, inefficient line of code, or missing architectural constraint that the AI initially produced.

• How did you catch it? (e.g., “The AI suggested a traditional index, but I am deploying on Snowflake/BigQuery which uses micro-partitioning instead of traditional indexes.”)

Part B: Code Modifications (The “Before & After”)

Show how you adapted the AI’s generic suggestion into production-grade code that aligns with our course database schema constraints.

• Initial AI-Generated Draft:

— Paste the unedited SQL snippet or configuration the AI gave you here.

• Iterative AI-Generated Modifications (multiple steps):

• — Paste your iterative prompts and explain exactly what you changed and why it was necessary for your specific database environment, and then the modification SQL snippet the AI gave you here.

• Your Modified Final Production Code:

— Paste the actual SQL code you deployed in your database here

Part C: Verification & Testing

How did you prove that your final code was accurate and performing optimally after modifying the AI’s work?

• State the validation methods you used (e.g., checking record counts against the source data, verifying datatype casting, running an EXPLAIN PLAN or measuring compute credit consumption).

Grading Rubric Snippet: AI Logging (Weight: 15% of Milestone Grade)

• Exemplary (Full Marks): Log is entirely complete. Student clearly demonstrated critical auditing of AI code, identified syntax/architectural mismatch errors, adjusted the code successfully for a cloud warehouse environment, and verified the output with metrics (e.g., execution plans, row counts).

• Developing (Partial Marks): Log is filled out, but student blindly accepted AI code without identifying inefficiencies. Code copies generic internet patterns rather than specific course architectural constraints. No clear validation metrics provided.

• Unacceptable (0 Marks): Evident AI code usage throughout the project with no accompanying log, or log contains blank/vague sections (e.g., writing “I asked it to help me fix my code” with no prompt or audit details).

Example 3: The Query Performance Trap (One week assignment)

The Scenario

The e-commerce database has a sales-transactions table with 12 million rows. The database administrator notices that the following query—designed to calculate total sales per product category for the year 2025—is running painfully slowly, taking over 45 seconds to execute and freeze up application resources.

The Assignment Task

1. Analyze the Problem: Identify why the current query forces a full table scan of all 12 million rows instead of utilizing the existing B-Tree index on the order_date column. (Hint: Look closely at the function being applied to the WHERE clause).

1. Rewrite the Query: Write an optimized version of this SQL statement that achieves the exact same result but allows the database engine to utilize the order_date index effectively, dropping the execution time to under 1 second.

1. Document Your Process: If you use GenAI to help you diagnose the performance trap or rewrite the syntax, you must complete the AI Interaction & Verification Mini-Log below and paste it at the top of your .sql submission file.

Required Submission Header: AI Interaction & Verification Mini-Log

Grading Guide for this Question (Total: 10 Points)

• Technical Correctness (7 Points): Did the student successfully rewrite the query to avoid applying a function to the indexed column? (The optimized solution should use a range comparison like WHERE order_date >= ‘2025-01-01’ AND order_date <= ‘2025-12-31’ or database-equivalent date range syntax).

• The Process Mini-Log (3 Points – Binary Check):

• Full Credit (3/3): The log is filled out completely. It clearly shows the student interacted with the tool, verified the outcome, and noted any adjustments made to move from a generic AI draft to their final tested query.

• No Credit (0/3): The code submitted is clearly AI-generated (using conventions not taught in class), but the log header is deleted, left blank, or filled out with placeholder fluff (e.g., “I just asked it to fix the query and it worked”).

Example 4: AI Transparency Policy for a writing assignment

Generative AI Transparency Policy: To encourage responsible innovation, you may utilize Gen AI tools for this assignment without penalty, provided you maintain absolute transparency. If you use AI at any stage, you must append an AI interaction log detailing for each use of AI tools:

• The name of the AI tool is used.

• The exact prompt(s) you submitted.

• The exact output generated by the AI.

• Your subsequent response or refinement step.

Generative AI Verification Policy: To document your writing, editing, and tool-interaction process, you are required to run your final text through two separate AI verification tools (such as Copyleaks, GPTZero, Turnitin, or Grammarly). Your final submission must include a Mandatory Attachment appended to the very end of your memo document containing:

• The complete final analysis report or clear screenshots from both checkers.

• The overall AI probability percentages.

• Any highlighted text segments from the analysis.

How This is Evaluated: An elevated AI detection score will not automatically result in a point deduction. The instructor will compare the checker’s results directly against your attached AI interaction log. Full compliance with the interaction tracking and the verification report ensures zero point deductions. However, submitting text that returns an AI signature without the required interaction log and verification attachment will result in a score of zero. The final analysis and personal insights must always remain in your own distinct synthesis and reflection.