tech-lab · course outline — Low Code, No Code & Generative AI

Technology with Impact — Low Code, No Code & Generative AI

A compulsory, 15-session course on the disruptive technologies reshaping how organizations are designed, managed and executed — taught through a practical, human-centered, build-it-yourself lens.

This course educates students on the disruptive technologies making an impact on some of the world's most pressing social challenges. It covers the latest technological trends and delves into a well-rounded analysis of technology — how it is implemented and how it is understood across different generations and cultures — focusing specifically on how society, organizations and people apply technology. A practical, human-centered approach helps students frame, develop and discover how technology can serve their future aspirations and solve real problems faced by society, organizations and individuals.

The course is built around a single thesis: software no longer needs to be written by professional developers to be valuable. Low-code platforms reduce hand-written code to a minimum; no-code platforms remove it entirely behind a visual interface; and generative AI lets anyone produce text, images and even working applications from a plain prompt. Together they turn business users into "citizen developers" who can ship a website, an app, an automated workflow or a chatbot in days rather than months — and the course asks students to weigh both the power and the risks of that shift.

Every concept here has a hands-on counterpart in the interactive demos: tune a Bass adoption curve, drop blocks in a no-code builder, wire a Zapier-style pipeline, tokenize text for an LLM, or watch a diffusion model denoise an image.

Program

IE-IMPACT · SEP-2025

Course code

TWI-IEIMPACT.2.M.G.NOCODE

Area

Functional Group — Program Direction

Sessions

Credits

3.0 ECTS

Academic year

25–26

Degree course

Second

Semester

1º

Learning objectives

By the end of the course, students will be able to demonstrate the following. Students also select a thematic course topic from areas such as Environmental Sciences, Financial Systems, Health & Technology, Innovation Engineering (low-code / no-code), Robotics & Industrial Automation, Sustainable Cities, Technology & Ethics, Technology & the SDGs, and Web, AI & Meta-Intelligence.

Course-level objectives

Demonstrate familiarity with the fundamentals of the disruptive technologies discussed in the course — knowing what each one is, when it applies, and where its limits lie.
Demonstrate knowledge of key technological trends in society, framing the technologies addressed in your course topic — and their latest developments — within them.
Reflect on how the use of these technologies affects and influences lifestyles, behaviors and views across different groups of people (generational and other profile or archetype differences).
Present & discuss a use case of how a technology has been or could be applied to solve a specific societal problem, applying critical thinking to identify the potential implications of its application.

Skills you will build

Understand the concept of "no-code" and its relevance in modern technology environments.
Use website, web-app and mobile-app builders effectively to develop digital products without coding.
Apply best practices for website design, content creation and digital product design.
Gain foundational knowledge of automation, RPA, chatbot design and generative AI.
Create and manage databases, integrate payment systems, and use generative tools to produce innovative digital products.

Methodology & assessment

IE's teaching method is collaborative, active and applied — students build their own knowledge and the professor leads and guides. The 3 ECTS map to ≈75 hours of student work, split across activity types below. Critical, acknowledged use of GenAI is encouraged throughout.

Learning-activity weighting (≈75 h total)

Individual studying40%

Group work20%

Lectures13.3%

Discussions13.3%

Exercises / async / field13.3%

Lectures 10 h · Discussions 10 h · Exercises/async/field 10 h · Group work 15 h · Individual study 30 h = 75 h.

Assessment weighting

Test (quiz 20% + case 20%)40%

Group work30%

Individual assignments15%

Class participation15%

Minimum passing grade is 5.0 (out of 10.0).

What each component asks for

Test — 40%. A closed-book quiz (20%) testing recall of course fundamentals, plus a closed-book open-ended case (20%) in which you analyse a scenario and argue a reasoned position. Sat in Session 13. Evaluated on accuracy, breadth of coverage and the quality of critical reasoning.
Group work — 30%. The term-long team project applying course technologies to a chosen social problem. Includes intermediate deliverables, a final presentation (Sessions 14–15) and a peer review. Evaluated on the fit of technology to problem, working artefacts built, clarity of the pitch and individual contribution.
Individual assignments — 15%. Assignments and take-home activities completed across the term. Evaluated on completeness, applied skill and acknowledged, critical use of any GenAI tools.
Class participation — 15%. Pre-class and in-class readings, videos, quizzes, discussion forums and other engagement activities. Evaluated on contribution quality and engagement — it must not consider attendance.

Re-sit, re-take & attendance rules

Each student has four (4) chances to pass a course, across two academic years: each year has one ordinary call and one extraordinary "re-sit" call in June/July.
Failing in the ordinary call leads to a June/July re-sit, a single comprehensive evaluation; continuous-evaluation components do not carry over and the grade is capped at 8.0 ("notable").
Re-sit format and dates cannot be changed and are announced in advance — plan summer commitments accordingly.
Not meeting the attendance requirement automatically fails both calls for the year, forcing re-enrolment the next year (re-takers contact IE-IMPACT to confirm in-person attendance rules).
Failing more than 18 ECTS after the re-sits means leaving the program. A graded-work review session is offered after each call.

GenAI policy — critical use encouraged

GenAI use is encouraged to build an informed, critical perspective on its uses and outputs.
Minimum-effort prompts give low-quality results — refining prompts is real work.
Never take output at face value: assume it is wrong unless you know the answer or can cross-check it; you own any errors.
AI is a tool you must acknowledge; doing so does not affect your grade, but failing to is an academic-honesty violation. State the system used, the prompts, and how outputs were used (or declare no AI content).

Program — full session structure

All 15 live in-person sessions, grouped by thematic module. Each module opens with an overview and learning outcomes; each session carries a per-topic explanation, the core idea or definition, a concrete example, the tools used, and a link to the matching interactive demo where one exists.

Module 0

Foundations & framing

Session 1

Sets the mental model for the whole course: what low-code, no-code and AI actually are, why they matter now, and how the term-long group project will work. The goal is shared vocabulary before any building starts.

After this module you can

Define low-code, no-code and the "citizen developer", and say when each fits.
Explain at a high level what AI is and why adoption is accelerating now.
Scope a realistic group project around a social problem.

Introduction

Set the stage: what the course covers, how it is run, and the group project that runs through the term.

Overview of the course — the arc from websites to apps, automation, data, chatbots and generative AI, and how each session builds on the last.
Introduction to the program — how IE-IMPACT, the thematic topic areas and the assessment fit together.
Introduction to the group project — teams pick a real societal problem and apply course technologies to it; intermediate deliverables feed the final presentation.
Introduction to no-code tools and platforms — software built through visual interfaces instead of written code, letting non-programmers ship products.
Introduction to artificial intelligence (AI) — systems that perform tasks normally needing human intelligence; the basis for later chatbot and generative-AI work.

Key idea: "Citizen developer" — a business user who builds working software on no-code/low-code platforms without formal programming training. Disruptive technologies tend to spread along an S-curve, slow at first then accelerating once adoption crosses a tipping point.

demo · adoption S-curve demo · network effects Simon — Low-Code/No-Code (framing)

Module 1

Website creation

Sessions 2–3

The first hands-on block: building a real website with a no-code builder and applying the design and content principles that make it usable and credible. Two sessions cover the same ground — the second is an applied workshop to iterate on what you started.

After this module you can

Build and publish a multi-page site on a no-code builder.
Apply layout, hierarchy and accessibility best practices.
Write clear, purpose-driven content with a consistent voice.

Website creation — builders & best practices

Get hands-on with no-code website builders and the principles of good web design.

Introduction to website builders — drag-and-drop platforms (Webflow, Wix, WordPress, Carrd) that turn visual blocks into a hosted, responsive site with no HTML/CSS written by hand.
Best practices for website design and content creation — visual hierarchy, whitespace, responsive layout, fast load, accessible contrast, and a clear call to action above the fold.

Key idea: A website builder trades fine-grained control for speed. Responsive design means one layout adapts across phone, tablet and desktop — judged by whether a visitor finds what they need in seconds.

demo · no-code builder Cabot — The Low-Code Handbook (ch. on web) Webflow / Wix / WordPress

Website creation — applied workshop

Continue building: apply design and content best practices to a working site.

Introduction to website builders — revisited in practice: structuring pages, navigation and reusable components on a live project.
Best practices for website design and content creation — applied to your own site: refine hierarchy, copy, imagery and the conversion path, then publish.

Key idea: Iteration beats perfection — ship a rough version, test it on a real reader, and improve the weakest screen first. Content and design are evaluated together, not separately.

demo · no-code builder Cabot — The Low-Code Handbook (best practices) Webflow / Wix / WordPress

Module 2

Web app & mobile app creation

Sessions 4–5

Moves from static pages to functional products — apps with logic, data and user accounts — built visually. You build a web app on one platform and a mobile app on another, then iterate in the applied workshop.

After this module you can

Distinguish a website from a web app from a native mobile app.
Build a data-driven web app in Bubble or Adalo and a mobile app in Thunkable or Glide.
Design app navigation and UX that match the platform's conventions.

Web & mobile app builders

Move beyond static sites: build functional apps visually on no-code platforms.

Introduction to web app builders — platforms where you define data, logic and screens visually, producing software that does something rather than just displaying content.
Creating a web app using Bubble or Adalo — a workflow editor wires user actions to database operations; e.g. a sign-up form that creates a user record and emails a welcome.
Creating a mobile app using Thunkable or Glide — Glide turns a spreadsheet into a phone app in minutes; Thunkable builds cross-platform apps with blocks.
Best practices for web app and mobile app design and content creation — clear navigation, minimal input friction, touch-friendly targets and fast perceived performance.

Key idea: A web app runs in the browser and updates data; a mobile app lives on the phone and can use device features. The data model — what records exist and how they relate — is the real backbone of any app.

demo · no-code builder Cabot — The Low-Code Handbook (apps) Bubble / Adalo · Thunkable / Glide

Web & mobile app builders — applied workshop

Deepen the build: iterate on app structure, data and UX on Bubble/Adalo and Thunkable/Glide.

Introduction to web app builders — applied: refine the data schema and the logic workflows behind your screens.
Creating a web app using Bubble or Adalo — add conditional logic, repeating lists bound to data, and user roles.
Creating a mobile app using Thunkable or Glide — connect a live data source and test on a real device.
Best practices for web app and mobile app design and content creation — reduce steps to value, handle empty and error states, and keep the UI consistent.

Key idea: Most app complexity hides in state and edge cases — what the screen shows when there is no data, a slow network, or a wrong input. Designing those states is what separates a demo from a usable product.

demo · no-code builder Simon — Low-Code/No-Code (citizen dev) Bubble / Adalo · Thunkable / Glide

Module 3

Automation & RPA

Sessions 6–7

Connect the tools so work happens without a human in the loop. Session 6 covers cloud workflow automation (app-to-app integrations); Session 7 covers RPA, where software bots imitate a person clicking through legacy systems.

After this module you can

Build a trigger-to-action workflow connecting two or more apps.
Explain how RPA differs from workflow automation and when each fits.
Judge automation ROI — which repetitive tasks are worth automating.

Automation — workflows

Connect apps so a trigger fires actions automatically, without manual steps.

Automating workflows using Zapier or Make — a trigger in one app (e.g. a new form response) fires one or more actions in others (add a row, send an email, post to Slack), often with filters and data mapping in between.

Key idea: Automation = trigger → (filter/transform) → action. Zapier is the simplest linear model; Make exposes a visual graph for branching multi-step scenarios. The skill is decomposing a manual routine into these steps.

demo · automation pipeline Cabot — The Low-Code Handbook (integration) Zapier / Make

Automation — robotic process automation (RPA)

Replace repetitive, rule-based human tasks with software bots, and judge when it pays off.

Robotic process automation (RPA) using UiPath or Automation Anywhere — bots that mimic human clicks and keystrokes across applications (including ones with no API), automating high-volume, rule-based desk work like data entry or invoice processing.

Key idea: RPA automates the user interface rather than connecting back-end systems, so it works on legacy software but is brittle when screens change. ROI rises with task volume, repetitiveness and error cost — the demo lets you tune those to see the break-even.

demo · RPA ROI demo · automation pipeline UiPath / Automation Anywhere

Module 4

Forms, payments & databases

Sessions 8–10

The data layer that makes products real: collecting input (forms), taking money (payments) and storing and querying everything (databases). These pieces plug straight into the automation flows from Module 3.

After this module you can

Design forms that capture clean, structured data and feed a workflow.
Integrate a payment provider into a no-code product.
Model, create and query a no-code database as an app's source of truth.

Forms

Capture structured input from users and feed it into automated workflows.

Creating forms using Google Forms or Typeform — questionnaires that validate input and write each response to a sheet or database; Typeform favours one-question-at-a-time UX and higher completion.
Best practices for automation, forms, and databases — ask only what you need, validate fields, and design the form as the entry point of an automated pipeline.

Key idea: A form is the front door to your data — clean structured input here prevents messy data everywhere downstream. Field validation enforces the right type/format at capture time.

demo · automation pipeline demo · no-code database Google Forms / Typeform

Payments

Add payment capability to a no-code product and connect it to the rest of the stack.

Integrating payment systems using Stripe or PayPal — a payment processor handles checkout, card data and compliance; a webhook then notifies your app when a payment succeeds so it can fulfil the order.
Best practices for automation, payment, and databases — never store raw card data, reconcile payments to records, and automate receipts and access on success.

Key idea: You never handle the card yourself — the processor does, and signals your app via a webhook. Payment success is just another trigger that can fire downstream automation.

demo · no-code database demo · automation pipeline Stripe / PayPal

Databases

Store, structure and query data as the backbone of any no-code application.

Introduction to databases — organised collections of records in tables (rows = records, columns = fields), with relationships linking related tables instead of duplicating data.
Creating and managing databases using Airtable or Google Sheets — Airtable is a relational, spreadsheet-friendly database with linked records, views and filters; Sheets is simpler but flat.
Best practices for automation, forms, payment, and databases — one source of truth, consistent field types, relationships over duplication, and views tailored to each use.

Key idea: A relational database links tables (e.g. orders → customers) so each fact is stored once. Good schema design — deciding the tables, fields and relationships up front — is what keeps an app maintainable as it grows.

demo · no-code database Airtable / Google Sheets

Module 5

Chatbots & generative AI

Sessions 11–12

The AI block: first rule- and intent-based chatbots, then generative AI — models that create new text and images. The course pairs how the models work with how to use them responsibly and acknowledge them.

After this module you can

Design a chatbot that maps user intents to the right responses.
Explain at a high level how LLMs and diffusion models generate output.
Produce and critique generated images, and prompt effectively.

Chatbots

Design conversational interfaces that route user messages to the right response.

Introduction to chatbots — conversational interfaces that interpret a user message and reply, ranging from fixed decision-tree flows to LLM-backed assistants.
Creating a chatbot using ManyChat or Tars — visual flow builders that map user intents to responses and actions across channels like web and messaging apps.
Best practices for chatbot design and implementation — clear scope, graceful fallbacks for unrecognised input, a human-handoff path, and a consistent persona.

Key idea: An intent is what the user is trying to do; the bot's job is to classify the message into the right intent and respond. The demo shows how fuzzy phrasing still routes to the correct intent — and what happens when nothing matches.

demo · chatbot intent routing Dhamani & Engler — Intro to Generative AI ManyChat / Tars

Generative AI — image generation

Understand how generative models work and use them to produce original images.

Introduction to generative AI — models trained on large datasets that generate new content; LLMs predict the next token of text, while image models learn the structure of images.
Generating images using Midjourney — a text-to-image diffusion model that starts from noise and iteratively denoises it toward an image matching the prompt; prompt wording, style and parameters steer the result.

Key idea: A diffusion model is trained to remove noise step by step, so it can turn pure noise into a coherent image guided by your prompt. LLMs work over tokens using attention to weigh which earlier words matter — all three demos make this visible.

demo · tokenizer demo · attention demo · diffusion Marr — Generative AI in Practice Midjourney

Module 6

Assessment & project

Sessions 13–15

The course closes by consolidating everything: a closed-book test of the fundamentals, then team presentations of the project that applied course technologies to a chosen social problem.

In this module you

Demonstrate command of the full course content under exam conditions.
Present and defend a technology use case for a societal problem.
Give and receive structured peer review.

Closed-book examination Test · 40%

Comprehensive closed-book assessment: a quiz (20%) plus an open-ended case (20%).

Closed-book quiz (20%) — recall and recognition across all six modules: definitions, tool fit, and best practices.
Closed-book open-ended case (20%) — analyse a realistic scenario, choose appropriate technologies, and argue the trade-offs and societal implications.

Key idea: The case rewards applied judgement over memorisation — matching the right tool to a problem and reasoning about consequences, exactly the course's stated objective.

14–15

Project presentations Group · 30%

Teams present their final group project — applying course technologies to a chosen social problem — with peer review.

Project presentations — each team demonstrates its built artefacts (site, app, automation, data or chatbot) and the problem they address.
Final deliverable, presentation and peer review — the final submission plus structured peer feedback; intermediate deliverables across the term also count toward the 30%.

Key idea: The project is the synthesis of the whole course — the grade reflects how well the chosen technologies actually fit the social problem, not how flashy the demo looks.

demo · impact prioritisation

Key concepts — glossary

The vocabulary that recurs across the program. Skim it before the exam; the closed-book quiz draws on these definitions and the tools they name.

No-code: Building software entirely through a visual interface, with no hand-written code, so non-programmers can ship products.
Low-code: Building software with mostly visual tools but the option to drop into code for the hard parts — a middle ground between no-code and traditional development.
Citizen developer: A business user who creates applications on no-code/low-code platforms without a formal software-engineering background.
Adoption S-curve: The typical shape of technology uptake over time: slow start, rapid middle growth, then saturation.
Network effect: When a product becomes more valuable as more people use it, accelerating adoption.
Website builder: A drag-and-drop platform (e.g. Webflow, Wix, WordPress) that produces a hosted, responsive site without coding.
Responsive design: One layout that adapts gracefully across phone, tablet and desktop screen sizes.
Web app vs. mobile app: A web app runs in the browser and manipulates data; a mobile app is installed on the device and can use its hardware features.
Data model / schema: The definition of what records an app stores, their fields and how tables relate — the backbone of any app.
UX (user experience): How easily and pleasantly a person reaches their goal in a product, including empty, loading and error states.
Workflow automation: Connecting apps so a trigger → filter → action sequence runs without manual steps (Zapier, Make).
Trigger / action: The event that starts an automation (trigger) and the operation it then performs (action).
RPA: Robotic Process Automation — software bots that mimic human clicks and keystrokes to automate repetitive, rule-based tasks across UIs.
API: An application programming interface — a defined way for software systems to talk to each other directly (contrast with RPA, which drives the UI).
Webhook: An automatic message one service sends another when an event happens — e.g. a payment processor notifying your app of a successful payment.
Form validation: Enforcing the correct type and format of input at capture time so downstream data stays clean.
Payment processor: A service (Stripe, PayPal) that handles checkout, card data and compliance so you never store raw card details.
Relational database: Data stored in linked tables (rows = records, columns = fields) so each fact lives in one place (Airtable).
Chatbot: A conversational interface that interprets a user message and replies, from fixed flows to LLM-backed assistants.
Intent: What a user is trying to accomplish with a message; a chatbot classifies the message into an intent to respond correctly.
Generative AI: Models that produce new content — text, images, code — learned from large training datasets.
LLM: Large Language Model — a model that generates text by predicting the next token given the preceding ones.
Token: The unit of text an LLM reads and predicts — roughly a word-piece; the tokenizer splits text into tokens.
Attention: The mechanism letting a model weigh which earlier tokens matter most when generating the next one.
Diffusion model: An image generator trained to remove noise step by step, turning random noise into an image guided by a prompt (Midjourney).
Prompt engineering: Crafting and refining the input to a generative model to get useful, accurate output — minimum-effort prompts give weak results.

Recommended bibliography

Core readings spanning generative AI and the low-code / no-code movement. The tag on each entry notes which sessions draw on it.

Introduction to Generative AI — Dhamani, Numa & Engler, Maggie (2024), Manning. ISBN 9781633437197
How LLMs work, integrating GenAI into workflows, balancing innovation and responsibility, the social/legal/policy landscape and where AI is going — the conceptual backbone for the chatbot and generative-AI sessions and the GenAI policy. · manning.com
used in · Sessions 11–12 · GenAI policy
Generative AI in Practice: 100+ Amazing Ways Generative AI is Changing Business — Marr, Bernard (2024), Wiley. ISBN 9781394245567
Risks and challenges, the changing job market, and GenAI's impact across education, healthcare, retail, media, design, banking and law — the "so what" for applying generative AI to a societal problem in the project. · wiley.com
used in · Session 12 · group project
The Low-Code Handbook — Cabot, Jordi (2024), Kindle. ISBN 9789998778504
A practical guide to the low-code landscape: platforms, integration and best practices — the reference for the building modules on websites, apps, automation and data. · lowcode-book.com
used in · Sessions 2–10
Low-Code/No-Code: Citizen Developers and the Surprising Future of Business Applications — Simon, Phil (2022), Racket Publishing. ISBN 9798985814736
The rise of citizen developers and the future of business applications — the framing read for why no-code matters and who builds with it. · philsimon.com
used in · Session 1 · Sessions 4–5