Executive MSc in Artificial Intelligence for Digital Transformation.

The session introduced calculus as a foundation for optimisation, machine learning and statistical modelling. It defined functions, linear and affine functions, and common nonlinear functions including powers, exponentials and logarithms. Derivatives were explained as local slopes, with rules for sums, constants, powers, products, quotients and composite functions, alongside links to neural-network differentiation. The class then extended derivatives to several variables through partial derivatives, higher-order and mixed partial derivatives, and their use in describing slopes in different directions. Taylor series and Taylor polynomials were presented as local approximations, with applications to numerical computation, optimisation methods and interpolation.

The session began with a recap of the product rule for derivatives, using a rectangle-area argument and the limit definition to show why the small product of two variations vanishes. It then introduced vectors as one-dimensional arrays, covering vector addition, scalar multiplication, linear combinations, and the importance of matching dimensions in mathematical and programming operations. Linear independence, dependence, collinearity and bases were explained as ways to identify redundant variables and reduce the dimensionality of data. The dot product, orthogonality, vector norms, normalisation and orthonormal bases were developed, with links to correlation, variance, regression and numerical scaling. The class also introduced changes of basis, including their role in principal component analysis (PCA), compression and viewing data from more informative directions.

The session examined matrix inverses, showing that a square matrix is invertible exactly when its columns are linearly independent, equivalently when it has full rank. It introduced matrix rank, numerical sensitivity near singular matrices, and the special simplicity of diagonal matrices, whose inverses and determinants can be computed element by element. Determinants were defined and calculated for two-by-two and three-by-three matrices using minors and cofactors, with discussion of why this recursive method is impractical for large matrices. The class then introduced trace, eigenvalues and eigenvectors for symmetric matrices, deriving the characteristic equation and using orthonormal eigenvectors to diagonalise a matrix through a change of basis.

The class examined how eigenvalues and eigenvectors in data analysis can reveal approximate linear relationships and support linear regression, including the effect of scaling variables and interpreting small eigenvalues as residual error. It covered adding an intercept through centring variables or including a column of ones, comparing resulting coefficients with a statistical regression model, and avoiding overfitting by selecting simpler models and validating them. The session also explained how changing to eigenvector coordinates can reveal trends in data that are not visible when plotting individual variables, linking this to principal component analysis. It then introduced positive-definite matrices and quadratic forms through the signs of eigenvalues, with applications to convexity and optimisation. Finally, it introduced complex eigenvalues of non-symmetric matrices, complex-number arithmetic, Cartesian and polar forms, and the use of complex exponentials in trigonometry and Fourier transforms.

The session introduced the course’s focus on probability, statistics and their role as foundations for machine learning, with R and RStudio as supporting tools. It reviewed mathematical notation for sums, products and sets, including unions, intersections and complements. Descriptive statistics were covered through frequency tables, bar charts, histograms, density plots and empirical cumulative distribution functions, with emphasis on interpreting distribution shape. The class defined quantiles, the median, mean, variance, standard deviation, interquartile range, skewness and kurtosis, and used box plots to examine spread and potential outliers. It then introduced multivariate descriptive analysis using contingency tables, scatter plots, covariance and correlation, stressing that correlation does not establish causation.

The session completed an introduction to probability distributions for finite, countably infinite and continuous sample spaces. It covered conditional probability, Bayes’ theorem and base rates through diagnostic-test, screening, production-defect and transmission examples, as well as the Monty Hall problem. Independence, incompatibility and mutual independence were distinguished using coin-toss and permutation examples. Students then completed practice multiple-choice questions on descriptive statistics, including means, medians, empirical cumulative distribution functions and probability calculations. The session ended by introducing random variables as functions mapping outcomes to real-number values and motivating probability distributions for them.

The session reviewed random variables through uniform, binomial, Poisson and normal distributions, focusing on their parameters, probability mass or density functions, cumulative probabilities, quantiles, means and variances. Simulated samples were compared with theoretical distributions to show how observed data can differ from ideal probability models. The class then introduced multivariate random variables, joint and marginal distributions, conditional distributions, independence, covariance and correlation, including a bivariate normal simulation and covariance matrix. It concluded with an introduction to convergence, random samples that are independent and identically distributed, parameter estimation, and the motivation for the law of large numbers and central limit theorem.

The session reviewed descriptive statistics, probability theory, random variables, probability distributions, convergence, the law of large numbers and the central limit theorem. It introduced estimators and estimations, including bias, variance, mean squared error and the use of large samples to improve estimates. Confidence intervals were explained as ranges around an estimate associated with a chosen risk level, and a practical activity used one-sample t-tests in R to calculate 95% and 99% confidence intervals for mean height. Statistical hypothesis testing was then introduced through null and alternative hypotheses, rejection regions, p-values, significance levels, and Type I and Type II errors, with examples involving coin tosses and comparisons of group means. The session concluded by outlining common tests for one mean, two means and independence, in preparation for further study.

The session introduced artificial intelligence as systems that perform tasks normally associated with human intelligence, distinguishing it from general artificial intelligence. It positioned machine learning as learning from data and deep learning as machine learning based on neural networks, while comparing neural networks with classical methods such as regression, random forests, boosting, clustering and support vector machines. Applications in computer vision, audio processing and natural language processing were explored, including image classification, object detection, segmentation, speech recognition, sentiment analysis and question answering. The machine-learning workflow was reviewed: defining objectives and success metrics, collecting and preparing data, selecting and evaluating models, deployment, monitoring and retraining in response to data drift. The class also covered labelled versus unlabelled data, the importance of balanced, shuffled and deduplicated datasets, and cautious use of sampling and data augmentation.

The session reviewed the relationship between artificial intelligence, machine learning, deep learning and neural networks, including the distinction between shallow and deep networks. It introduced PyTorch tensor handling, device selection, graphics processing unit (GPU) availability and moving data between the central processing unit (CPU) and GPU. Data preparation for neural networks was covered through numerical encoding, ordinal and one-hot encoding, and feature scaling using min-max scaling and standardisation. The training cycle was explained: feeding data in batches, forward propagation, loss calculation, backpropagation and parameter updates across epochs. The class examined mean squared error and binary cross-entropy losses, gradient descent, learning rates, vanishing gradients, and batch, stochastic and mini-batch strategies, before comparing momentum, Adagrad, RMSProp and Adam optimisers.

The session reviewed how neural-network models should generalise to unseen data and how datasets should be divided into training, validation and test sets. It covered epochs, mini-batches, loss functions, backpropagation, gradient descent, learning rates and optimisers, including momentum and Adam. The class examined underfitting, overfitting, the bias–variance trade-off, early stopping, model complexity, regularisation, and the importance of data quality and relevant features. It also discussed avoiding data leakage, maintaining comparable distributions across data splits through stratified sampling, and balancing groups where fairness requires it. Students then practised structuring a PyTorch workflow with datasets, data loaders, models, training loops and validation-loss logging in TensorBoard.

The session examined how training and validation curves can indicate overfitting, underfitting, unstable optimisation and the need for early stopping. It covered causes and remedies for poor generalisation, including improving data quality, increasing data or model capacity where appropriate, removing irrelevant features, and adjusting learning rate and batch size. Regularisation methods were explained, including L1 and L2 penalties, dropout, data augmentation and batch normalisation, alongside vanishing gradients and internal covariate shift. The class also discussed why deep networks learn hierarchical features, their advantages for complex unstructured data, and their limitations in computation, data requirements and interpretability. In practical work, students added batch normalisation, dropout and L2 weight decay to a PyTorch classifier, then used Optuna to tune hyperparameters and inspect the resulting trials.

The session introduced the structure of the machine learning course, including its focus on exploratory data analysis, feature engineering and modelling within a complete machine learning pipeline. A group project was outlined in which students were asked to use book metadata to predict Goodreads ratings, clean and analyse imperfect data, compare at least two models, and deliver code, a simple application, a report, a video demonstration and a GitHub repository. The class emphasised that machine learning begins with a clearly defined problem, suitable data and an understanding of how a human would approach the task. It also reviewed Python foundations needed for machine learning, including built-in data structures, mutability and immutability, indexing, conditions, loops and functions.

The session reviewed pandas data frames, including their tabular structure, indexing, comma-separated values (CSV) import, and the use of head(), tail() and describe() for inspection. It introduced the Titanic data set as a continuing case study and defined the machine-learning task as predicting passenger survival from available passenger information. The class examined data quality issues such as missing ages, identified the target column and ground truth, and discussed class imbalance and its effect on model bias. It also interpreted summary statistics, distributions, standard deviation and outliers, considering when unusual cases should be retained, removed or contextualised through additional features.

The session reviewed exploratory data analysis and feature engineering using the Titanic data set, including handling missing values, removing unhelpful columns and considering bias when retaining scarce passenger profiles. It demonstrated how to extract structured titles from unstructured name text using string splitting, indexing, slicing, functions and DataFrame apply operations, then create and analyse a new title feature. The class examined how uneven category frequencies can limit the usefulness of a feature for machine-learning models. It also introduced data visualisation with Plotly, using wine-quality data to inspect distributions, relationships and outliers, housing data to map prices geographically, and stock and country data to show changes over time.

The session completed exploratory analysis and feature engineering for a Titanic survival prediction task. It examined missing data, gender, passenger class, age distributions, fares and outliers, using bar charts, pie charts, histograms, distribution plots and box plots to identify relationships with survival. The class discussed removing unhelpful columns, imputing missing ages using grouped averages, and preparing data so that it is numerical and suitable for machine learning. It introduced ordinal/label encoding and one-hot/vector encoding, including their trade-offs, the k−1 rule, and the encoding of binary and passenger-class variables. The session then introduced the distinction between training and testing data, explaining how models learn from labelled examples and are evaluated on unseen examples.

The Web was distinguished from the Internet as a distributed hypermedia application, built around Uniform Resource Locators (URLs), the Hypertext Transfer Protocol (HTTP) and Hypertext Markup Language (HTML). The session traced a path through structured documents using Extensible Markup Language (XML) to linked data and Resource Description Framework (RDF) graphs. Knowledge graphs connected named entities and relationships across datasets, supporting search, recommendation, integration, validation and reasoning. Retrieval-augmented generation was another application considered. The discussion also examined data collection, tracking, algorithmic influence and biased datasets, bringing privacy, accessibility and ethics into the technical picture.

RDF statements were studied as triples forming directed, labelled graphs. Uniform Resource Identifiers (URIs), literals and blank nodes supplied the building blocks for linking data across datasets. Students practised graph completion and learnt N-Triples, Turtle and RDF/XML syntax, including prefixes, namespaces, typed values and language tags. Activities included validating, converting and visualising data, creating a personal RDF profile and examining an external library dataset. The practical guidance was to test incrementally and check generated RDF rather than copying the output of artificial intelligence without verification.

SPARQL, the query language for RDF, introduced a way to ask questions by matching patterns in a graph. Students constructed patterns with triples, variables, prefixes and filters, then practised SELECT queries, distinct results, ordering and pagination. Remote endpoints such as DBpedia and Wikidata provided datasets to query. Further exercises used optional patterns, alternatives, exclusions and supplied values, alongside type and language tests, casting and string functions. Translating natural-language requests into queries connected the syntax to a precise account of which graph matches should be returned.

Ontologies were introduced as shared, formal vocabularies that give data meaning and support logical inference. Classes, properties and their definitions were distinguished from taxonomies, thesauri and validation schemas such as Shapes Constraint Language (SHACL). A museum modelling exercise exposed ambiguity, user needs, domain expertise and cultural assumptions. RDF Schema (RDFS) then provided classes, subclass and subproperty hierarchies, domains and ranges. Examples showed how these declarations allow additional types and relationships to be inferred, making the consequences of a model’s definitions visible in the graph.

An RDFS lab showed how loading a schema and enabling reasoning changes the available triples and query results. The Web Ontology Language (OWL) introduced richer class definitions and property relationships, including intersections, disjointness, equivalence, restrictions, inverse relations and property chains. Students interpreted axioms and predicted inferred facts from small graphs, using biological and organisational examples. Restrictions on values and cardinalities extended the modelling possibilities. Open-world reasoning and the absence of a unique-name assumption were central cautions: incomplete information and different names cannot simply be treated as proof of absence or difference.

Media Fragments and a media-resources ontology introduced descriptions of image regions, audiovisual segments and tracks. Students considered how to assess existing vocabularies through their definitions, scope, reuse and expressivity, and how validation supports data quality. The session surveyed mappings from relational databases, HTML, JavaScript Object Notation (JSON) and comma-separated values (CSV) into RDF. JSON for Linking Data (JSON-LD) contexts and other mapping standards connected familiar formats to graphs. Practical work included extracting embedded triples, interpreting mappings and converting profiles to JSON-LD. The Linked Data Platform introduced managing RDF resources and containers through HTTP operations.

The session introduced analysis and design as the work required before implementation, stressing the need to clarify requirements and plan solutions before writing code. It examined software complexity through the large number of possible system states, using general-purpose tools such as spreadsheets to show why complete testing is often impossible. The class compared information technology challenges with mathematically modelled engineering problems, and discussed the limitations of generative artificial intelligence and machine learning as tools for reasoning and software development. It defined information systems as organised processes for transforming data into information and potentially knowledge, with data models enabling useful access to raw data. The session also used the house-building analogy to explain requirements analysis, design, implementation, compliance, integration, security, maintenance, liability and software quality.

The session introduced information-systems analysis as the phase for understanding business needs before making design or technology choices. It covered requirements, stakeholders, business rules, events, data attributes and data dictionaries, emphasising the need to distinguish what a system must achieve from how it will be implemented. The class compared models and methods, explaining that models represent reality while methods provide steps for operating on a model, and discussed why analysis relies on clear, simple models rather than a guaranteed method. Examples involving JavaScript Object Notation (JSON), Extensible Markup Language (XML) and user-interface prototyping illustrated the importance of precise terminology, data representation, validation, and documenting operational requirements.

The session introduced context diagrams for analysing an information system as a black box, identifying external actors, events and time-driven triggers. It explained the distinction between data-carrying events and signals, and compared pulling data from external sources with receiving pushed data through gateways, queues and agreed protocols. The class examined application programming interfaces (APIs) as interfaces exposing reusable software functions, particularly for exchanging data between systems. It then modelled responses to events as action flowcharts, using checks for mandatory attributes and duplicates before creating a customer, and distinguished programming from coding and software engineering. The session also began data-dictionary analysis, discussing attributes, identifiers, universally unique identifiers (UUIDs), relational versus graph databases, scalability, transaction management and data-privacy implications of universal identifiers.

The session examined the relational data model, including relations, attributes, tuples, primary keys and foreign keys. It explained how functional dependencies are identified through business context and used to derive tables, keys and associations, with one-to-one relationships considered before many-to-many relationships. Relational algebra was introduced as the basis of Structured Query Language (SQL), covering selection, projection and joins, alongside query planning and optimisation using database statistics. The class began normalisation, focusing on first normal form and atomic values, then second normal form and the problems caused by partial dependencies in composite keys. A human-resources allocation example was used to show data inconsistency, redundant storage and the need for programmed checks to enforce dynamic constraints such as overlapping employment periods.

The session introduced the course structure and its aim of preparing students to participate in or lead data science projects. It contrasted traditional, waterfall-style project management with agile approaches, explaining time-boxed sprints, sprint reviews, retrospectives, planning and visual task boards. A project was defined as a temporary undertaking with a unique objective, a defined timescale and required resources, distinguishing it from routine operations. The class also examined product and sprint backlogs, prioritisation, team commitment, transparency and measuring progress. Business cases, break-even points, return on investment and the need to reassess a project when business conditions change were introduced.

The session began with sprint planning and reflection, using completed work and team capacity to agree a realistic commitment for the next sprint. It covered project vision statements, the limitations of AI-generated content, and the need to understand project-management concepts well enough to assess artificial intelligence (AI) outputs critically. Key traditional project-management concepts included the triple constraint of scope, time and cost; project life-cycle phases; uncertainty, risk and the rising cost of change; and the Project Management Institute (PMI) waterfall framework, including project charters, planning, resources, communication, procurement and stakeholder management. Students practised preparing elements of a project charter and assigning stakeholder roles through a responsible, accountable, consulted and informed (RACI) matrix, then discussed stakeholder power and influence. The class also covered Gantt charts, task estimation, S-curves, earned value, cost and schedule variance, key performance indicators (KPIs), and the Plan-Do-Check-Act cycle.

The session used a simulated sprint review, retrospective and planning exercise to demonstrate approval of completed work, velocity tracking, forecasting and commitment to a minimum sprint scope. It introduced Agile values from the Agile Manifesto, stressing individuals and interactions, working software, customer collaboration and responding to change whilst recognising the continuing value of plans, documentation and contracts. Agile and waterfall approaches were compared in terms of fixed constraints, planning, suitability for different levels of uncertainty, stakeholder involvement and regulated environments. The class examined timeboxing, incremental delivery, technical debt, minimum viable products, proof of concepts, product backlogs, prioritisation and Agile contract models. It also covered the roles of the product owner, Scrum Master and self-managing cross-functional teams, followed by a scenario activity, quiz and video on Agile product ownership.

The session showed how an agile backlog can be adapted as new information emerges, using prioritised user stories and changing investigation scenarios to illustrate this process. It emphasised the importance of direct, timely communication for agile teams, particularly where teams are distributed. Agile software development practices included automated testing, continuous integration and delivery, code standards, collective code ownership, technical-debt reduction, and responsible use of AI-assisted programming. The class then introduced scaled agile working through Scaled Agile Framework (SAFe), including Agile Release Trains, programme increments, programme increment (PI) planning, cross-team dependencies, and the roles of product manager, Release Train Engineer and system architect. It also considered how agile delivery can be connected with wider business strategy and product value.

The session introduced relational databases, explaining how tabular data is organised into rows and columns and how tables are linked through primary and foreign keys. It contrasted relational and non-relational data models, using document and key-value structures to show why highly variable data may create sparse tables. The class explained client-server database architecture, including database servers, clients, web interfaces, back-end code, SQL queries, connection details and access permissions. It also compared proprietary and open-source database systems, and outlined the course case-study approach and SQL-based assessment.

The session covered restoring a SQL Server database from a backup file, including verifying the backup and using the database interface to inspect tables. It reviewed relational tables, primary and foreign keys, schemas, and the use of schemas for functional organisation and access permissions. Students wrote basic SQL queries using SELECT, FROM, USE and COUNT, and discussed why row counts should be checked before using SELECT * on an unfamiliar or very large table. The class also examined database collation, including case and accent sensitivity, and explored customer data to identify data-quality inconsistencies and infer how customer and billing identifiers were structured.

Self-joins compared product prices, including a query for non-USB products priced at least as highly as a USB product. Text filters, wildcard placement and case conversion affected which rows matched; DISTINCT addressed repeated results from multiple comparisons. An entity–relationship diagram then connected customers, orders and invoices through their keys. The class explored orders without invoices using an outer join with missing-value filtering and alternative subqueries. These examples led into invoice structure: identifiers, dates, line items, quantities, prices and totals. The queries were examined in their data context, without asserting that every alternative behaves identically for all missing values.

The session reviewed database normalisation, covering first, second, third and Boyce-Codd normal forms, functional dependencies, atomic values, composite keys and the risks of duplicated or dependent non-key data. Examples from a sample database were used to identify non-atomic JavaScript Object Notation (JSON)-style fields and third-normal-form breaches that could create inconsistent customer and invoice information. The class then restored and explored a second SQL Server database, checked table keys and case-sensitive collation, and used the graphical interface to add and edit a city column. Finally, it practised GROUP BY, COUNT and HAVING, then developed two approaches for finding customers who had bought every product, including a division query using nested NOT EXISTS conditions.

The session introduced Neo4j as a native, schema-optional graph database and compared its relationship-focused storage with relational databases. It covered graph theory fundamentals, including nodes, relationships, directed and weighted graphs, labels, properties and shortest-path traversal. Students explored common graph-database applications such as fraud detection, recommendation systems and network analysis. The class introduced Cypher syntax for matching, filtering and returning nodes and relationships, using a movie graph dataset for practical queries. Students also practised creating nodes and relationships with MERGE, updating or removing properties, and using conditional creation and matching behaviour.

The session demonstrated how to import comma-separated values (CSV) data into Neo4j, create uniqueness constraints, load person, location and visit nodes, and create relationships between them. It then introduced intermediate Cypher querying, including case-insensitive string filtering, checking query plans with EXPLAIN and PROFILE, and writing efficient graph traversal patterns. Further activities covered OPTIONAL MATCH, ordering, filtering null values, limiting and paginating results, and removing duplicates with DISTINCT. The class also practised map projections and CASE expressions to customise returned JSON-style objects and categorise movie runtimes.

The session introduced cloud computing models, service types and deployment approaches, including the benefits and limitations of public, private, hybrid and multi-cloud environments. It compared using Neo4j through Amazon Web Services (AWS), Google Cloud and Azure marketplaces, including single instances, clustered deployments, containers and relevant certification routes. The class then practised intermediate Cypher queries using aggregation functions such as COUNT, COLLECT, SUM, AVG, MIN and MAX, alongside DISTINCT, UNWIND, list indexing and list slicing. It also covered date, time and duration values in Cypher, including calculating intervals and converting timestamps for comparisons. Students continued the COVID graph mini-project exercises.

Data formats were distinguished from web programming languages and human-readable presentation. XML introduced nested elements, attributes, declarations and a tree structure, alongside the distinction between well-formedness and validation. Namespaces, resource identifiers and language tags addressed how names and context are expressed. Students created, formatted and viewed a simple document in an editor and browser. Comparison with JSON and graph-based semantic data placed the exercise within a wider discussion of representations used to exchange information between systems.

XML Schema introduced simple and complex types, element and attribute declarations, and rules governing how often information can occur. Ranges, patterns and enumerations constrained values, while type extension offered a way to build on definitions. Students created and validated schemas for bibliography and film data, deliberately adding or removing information to test the rules. Namespace and schema-location declarations connected documents to their definitions. Work then began on more precise types for a curriculum example within the session.

XPath expressions introduced paths, tests and conditions for selecting nodes in an XML tree. Extensible Stylesheet Language Transformations (XSLT) then used matching templates to generate other representations. The class examined template application, default rules, specificity, extracted values and dynamically constructed output. Catalogue and film examples supported activities in filtering, counting, sorting and formatting results for web presentation. The focus was on transforming existing structured information through declared rules rather than manually reproducing each output record by hand.

JSON objects, arrays and primitive values were compared with XML structures. Ordered collections and repeated items led into JSON Schema rules for properties, required fields, types and constraints. Students created representations and schemas for bibliographies, catalogues and film data, then changed the data to test validation. Restrictions on additional information and dependencies extended the contract beyond basic types. The class also prepared to transform XML film records into JSON using XSLT, carrying the transformation theme across formats.

The session introduced data engineering on AWS, focusing on the five Vs of data: value, veracity, volume, velocity and variety. It explained data pipelines, including extract, transform and load (ETL) and extract, load and transform (ELT) approaches, structured and unstructured data, and the choice between batch and streaming processing. AWS ingestion services were covered, including AppFlow for software-as-a-service data, DataSync for file transfers, and Data Exchange for third-party data. The class examined AWS Glue for data catalogues, crawlers, ETL jobs, schema management, data quality and handling sensitive information. Streaming tools including Kinesis Data Firehose, Kinesis Data Streams, managed Apache Flink and Kafka services were compared, alongside data lakes, data warehouses, Lake Formation, Athena, Redshift and OpenSearch.

Disaster recovery planning connected acceptable data loss and recovery delay with storage, computing, databases and networks. Backups, snapshots and cross-region replication were compared, including why replication alone does not protect against corruption. The class reviewed storage migration, lifecycle management and shared file services, then considered machine recovery, automatic scaling, load balancing and regional failover. Managed database recovery and repeatable infrastructure deployment added further recovery options. A guided hybrid-storage lab covered configuring storage, moving files to Amazon Simple Storage Service (S3) and replicating data into another region, connecting architectural choices with the mechanics of protecting and moving data.

The session completed the disaster recovery module by reviewing recovery point objectives (RPOs), recovery time objectives (RTOs), and the relationship between disaster recovery and business continuity planning. It covered AWS services and approaches for resilience, including S3 replication, Storage Gateway, Amazon Machine Images, snapshots, CloudFormation infrastructure as code, Route 53 health checks and failover. Four disaster recovery patterns were compared: backup and restore, pilot light, warm standby, and multi-site active-active, with emphasis on their cost, recovery speed and suitable use cases. Students worked through knowledge-check and exam-style questions on selecting the appropriate recovery pattern and AWS service for different scenarios. The session also introduced the certification exam structure, exam guide and practice-question resources.

Certification preparation used a modular study guide and short quizzes to identify topics needing further revision. The material revisited computing, storage, networking, databases and security, alongside name resolution, logging, resilience, performance and cost. Students were shown how quiz results could guide their study rather than treating every topic as equally familiar. Additional resources included hands-on AWS practice environments, an architecture project and configurable practice tests. The session concerned ways to prepare and assess understanding; the source does not establish completion of the project or an eventual certification result.

The session reviewed commonly misunderstood AWS concepts in preparation for an assessment. It covered service-level agreements, Elastic Compute Cloud (EC2) Auto Scaling, S3 durability, encryption and access logs, virtual private cloud (VPC) networking, network address translation (NAT) gateways, VPC peering, security groups and availability zones. It also compared relational databases with DynamoDB, explained Identity and Access Management (IAM) permissions and roles, and distinguished CloudWatch, CloudTrail and AWS Config for monitoring and auditing. Further topics included messaging with SNS and SQS, CloudFormation, caching, VPC flow logs, cost-allocation tags, SSL offloading, and gateway versus interface VPC endpoints. Practice-question answers were used to reinforce how to select appropriate AWS services for performance, security, scalability and cost management.

The session introduced cybersecurity through physical security, secure system design and the importance of planning security controls early. It examined software-update lifecycles, vulnerabilities, exploit value, mass surveillance risks and the security implications of physical access to devices. Students used a virtual machine to create a memory dump after a failed web login, extract readable strings, locate credentials in memory, and use regular expressions and CyberChef to transform data. The class also covered symmetric and asymmetric encryption, public and private keys, certificate authorities, and the role of trust in encrypted web connections. Further examples illustrated how memory modification, malicious USB devices and keystroke injection can compromise systems.

The session examined social engineering and phishing, including how attackers impersonate brands through misleading URLs, fake applications, adverts and artificial-intelligence-generated content. Students learned to identify the genuine domain within a URL, recognise typosquatting and subdomain deception, and understand how phishing pages can evade automated detection through obfuscation. The class compared authentication methods, covering strong unique passwords, password managers, multi-factor authentication, passkeys and hardware security keys, with emphasis on phishing-resistant FIDO2 (Fast Identity Online) authentication. It also covered wireless threats such as evil-twin access points, physical attacks on devices and firmware, data-at-rest encryption, and the use of BitLocker or FileVault to protect stored data. Practical activities included analysing password recovery from video, considering cloned-audio scams, and resetting a local Windows password in a virtual machine to demonstrate the importance of disk encryption.

The session introduced FTP as a file-transfer protocol and compared command-line FTP with the FileZilla graphical client. Students used Wireshark to capture network traffic, inspect packets, and observe that unencrypted FTP credentials can appear in clear text, whereas Transport Layer Security (TLS) protects data in transit. The class examined denial-of-service concepts, including bandwidth saturation, packet flooding and socket exhaustion, through controlled demonstrations using ping, hping3 and Slowloris. It also covered the MITRE ATT&CK and D3FEND frameworks, Common Vulnerabilities and Exposures (CVE) and Common Weakness Enumeration (CWE) identifiers, and Common Vulnerability Scoring System (CVSS) scores for assessing vulnerabilities and their impact.

The session reviewed network reconnaissance: identifying an Internet Protocol (IP) address range, finding active hosts with ping sweeps, scanning exposed services with Nmap, and selecting appropriate tools to interact with those services. It demonstrated how anonymous FTP access, weak passwords and excessive permissions can expose files and enable unauthorised access, alongside the principle of least privilege and password-strength considerations. The class explored credential attacks and defences, including word lists, online and offline password cracking, stronger authentication, virtual private networks (VPNs), port knocking and canary accounts. It also covered local-network interception techniques, including name-resolution poisoning, Address Resolution Protocol (ARP) cache poisoning and man-in-the-middle attacks, plus the use of Wireshark and defensive monitoring. Finally, it introduced open-source intelligence, advanced search modifiers, subdomain discovery, cloud-hosted services and Shodan for identifying internet-exposed assets.

The session examined why some software vulnerabilities are difficult to eliminate at scale, including memory-corruption flaws, Rowhammer and the move towards memory-safe languages such as Rust. It discussed ransomware as a criminal business model, including encryption, data theft, double extortion, negotiation and money laundering. Students used CyberChef to practise data extraction with regular expressions and to explore Base64 encoding, Advanced Encryption Standard (AES) encryption, entropy and frequency analysis. The class also considered how phishing sites imitate legitimate services and how users can identify them by checking context, urgency and domain names.

The session introduced the aims of production-grade data engineering, including end-to-end pipelines, common engineering patterns, infrastructure as code, continuous integration and delivery (CI/CD) and the role of data engineers in connecting transactional and analytical systems. It compared online transaction processing (OLTP) and online analytical processing (OLAP) workloads, discussed data lakes and lakehouses, and explained why SQL and self-service data solutions are widely used. The class covered conceptual, logical and physical data modelling; normalisation through the first, second and third normal forms; denormalisation; star and snowflake schemas; slowly changing dimensions; fact tables and dimension tables. It also examined data retention, sampling, bucketing, query plans, pre-computation and data-granularity trade-offs, including bit-based date-list encoding for efficient activity and churn queries. The final section introduced functional programming principles for pipelines, especially atomicity, idempotency and avoiding side effects, alongside factory and strategy design patterns in Python ETL code.

The session explained Python context managers, data classes and Pydantic models as ways to manage resources safely, represent structured data clearly and validate incoming JavaScript Object Notation (JSON) data early. It covered pytest features including parametrised tests, fixtures, exception testing, test-driven development, mocking and dependency injection, with emphasis on testing transformation logic and Spark applications. Further Python topics included caching, decorators, object references versus copies in pandas, type hints, protocols, singleton design and avoiding magic strings and excessive coupling. The class then introduced Hadoop-related technologies, Parquet compression and Hive metadata, alongside Ranger-based data-access controls. It also covered distributed processing and Spark concepts, including MapReduce, lazy evaluation, partitioning, joins, testing, and the write-audit-publish pattern for data quality.

The session introduced Amazon Web Services (AWS) Glue as a serverless way to run Spark workloads and use a central data catalogue, alongside other cloud and orchestration options. It explained lakehouse architecture and Apache Iceberg table formats, focusing on metadata, snapshots, manifests, partition pruning, time travel, schema and partition evolution, upserts, and write-audit-publish workflows. Practical exercises were outlined for using Spark, Iceberg and Docker to create tables, merge data, inspect metadata, and validate data before publication. The session also covered infrastructure as code with Terraform, including providers, resources, variables, modules, dependencies, plans, state, identity and access management (IAM) permissions and scheduled AWS Lambda deployments. Finally, it refreshed CI/CD concepts such as pipelines, runners, artefacts, reusable container images, formatting checks and security scanning for Terraform.

The session developed an AWS data pipeline that moves change-data-capture files from a transactional system into Iceberg tables for analytical use. It demonstrated creating Glue catalogue databases and Iceberg tables, then using Spark SQL MERGE operations to apply inserts, updates and deletions to users and orders data. A country-level analytics table was built by joining the source tables, deriving order years and aggregating order values. The prototype was then refactored towards a production-oriented design using modular Python code, typed configuration, unit tests, Terraform-managed infrastructure, least-privilege identity and access management (IAM) permissions and deployment of code artefacts to S3. The session also discussed how orchestration tools could detect arriving files and trigger Glue jobs with runtime parameters.

The session introduced the legal, ethical and geopolitical issues raised by data and artificial intelligence, emphasising that regulation varies across jurisdictions and societal contexts. It explored why artificial intelligence (AI) and data engage areas including data protection, liability, intellectual property, constitutional law, international law and discrimination. Students considered the limits of using AI in legal decision-making, including predictive systems for human-rights cases, balancing legal certainty and efficiency against human interpretation and the evolving nature of law. The class also examined definitions of AI, the distinction between narrow and general AI, calls to regulate future technological risks, and the possible legal personhood of robots. A case discussion considered arguments for and against a conversational robot inheriting an owner’s assets.

The session examined the development and purpose of the European Union (EU) AI Act, including tensions between innovation, competitiveness, sovereignty, public regulation and private ethical codes. It distinguished legal obligations from voluntary ethical commitments, explaining why enforceable rules and sanctions are significant. The class explored the Act’s risk-based model, covering prohibited, high-risk, limited-risk and minimal-risk AI systems, alongside the duties imposed on providers and other actors. It also considered the Act’s extraterritorial reach, exclusions such as military and research uses, enforcement mechanisms, regulatory sandboxes, and the particular rules for general-purpose AI models. Students discussed practical difficulties in assessing risks to fundamental rights, democracy and human dignity, as well as potential conflicts between European and international regulatory approaches.

The session introduced data protection law through discussion of children’s data, profiling, algorithmic bias and the limits of consent in digital services. It examined why data protection is important for AI, comparing the European rights-based approach with the more sector-specific approach in the United States. The class covered privacy as a broader concept than information control, including dignity, intimacy, home and communications, and considered the EU Charter rights to privacy and personal-data protection. It then introduced the General Data Protection Regulation (GDPR), including personal data, identifiable natural persons, processing activities, material and territorial scope, and the basic obligations on organisations processing data. Students discussed examples involving health data, policing, profiling, data transfers and cross-border services.

The session examined GDPR data-subject rights in AI systems, including access, rectification, erasure, restriction of processing, portability and objection, and explained privacy by design across training and deployment. It considered how biased datasets and algorithmic design can create or reinforce discrimination, and discussed fairness, auditing, impact assessments and ethics by design. The class then introduced the EU Data Act, its application to data from connected products and related services, its relationship with the GDPR, and rules on user-led data sharing, competition, gatekeepers, contracts, compensation and dispute resolution. The final section used neurotechnology to explore mental privacy, brain data, cognitive liberty, and the need for ethical and legal safeguards against misuse by companies or governments.

The session examined the ethical, legal and professional responsibilities of scientists and data specialists in relation to autonomous lethal weapons and AI used in conflict. It considered the limits of existing regulation, particularly the military exemption in the AI Act, and debated whether emerging technologies should be regulated or prohibited before they are fully developed. The class compared arguments for and against autonomous weapons, including meaningful human control, bias, accountability, international consensus and historical preventive bans on certain weapons. It also discussed whether advanced AI systems merely imitate reasoning or might develop forms of understanding or consciousness, and considered the implications for law and responsibility. Finally, the session explored corporate due diligence, value-chain oversight and contractual controls through examples of technology companies supplying tools that may be used for immigration enforcement, surveillance or defence.

The session introduced artificial intelligence (AI) as a long-standing research problem, covering the Turing test and the history of symbolic, neural and hybrid approaches to AI. It explained that large language models use neural networks to identify and extend patterns in large datasets, rather than necessarily understanding logic, facts or context. The class compared rule-based chatbots with neural networks, discussed limitations including hallucinations, data quality, context and ethical risks, and considered neurosymbolic AI as a possible future direction. It also distinguished supervised, unsupervised and semi-supervised learning through examples of image classification and recommendation systems, and stressed the importance of reliable data and good software engineering practice.

The session introduced the scope of advanced Excel, including pivot tables, data transformation and modelling with Power Query, Power Pivot and Data Analysis Expressions (DAX), and a later introduction to Visual Basic for Applications (VBA). It examined Excel as a powerful but potentially risky tool, focusing on data completeness, accuracy, validity, access control, versioning and the dangers of links between separate workbooks. Students were taught to treat spreadsheets as systems with distinct input, processing and output areas, using ideas drawn from software architecture. Design priorities such as relevance, simplicity, scalability, robustness, auditability and productivity were discussed as trade-offs. The class then began independent work through exercises on pivot tables.

The session reviewed spreadsheet risk management using completeness, accuracy, validity and restricted access, alongside trade-offs between usability, simplicity, robustness and productivity. It introduced a level-one Excel architecture that separates input, processing and output areas, using Excel tables, lookups, aggregations, pivot tables and GETPIVOTDATA to create stable reports. Students worked on a billing-report exercise involving a date dimension, data enrichment with XLOOKUP, a pivot table, and a report or dashboard. The class also discussed continuous date dimensions, handling unmatched lookup values as data-quality and referential-integrity issues, and the purpose of dynamic array functions, including UNIQUE, SORT and FILTER.

The session introduced Power Query as Excel’s extract, transform and load tool, and compared level 2 spreadsheet architecture with a grid-only approach. It explained how Power Query connects to external sources, transforms data before loading it, and can load results to an Excel table, a PivotTable cache or the data model. The class covered the importance of managing data types, including choosing efficient date and currency types, and discussed when calculations or aggregations should be performed in Power Query rather than in the grid. A demonstration showed how to create queries from Excel tables, review and edit transformation steps, use connection-only loading, navigate between Excel and the Power Query Editor, and begin working with M code and the Advanced Editor. The session also clarified the use of number formats for PivotTable values.

The session introduced Power Pivot as Excel’s business-intelligence tool and compared a level 2 spreadsheet design with a level 3 design based on a data model. It explained how Power Query prepares separate fact and dimension tables, which are then related in a data model rather than merged into one large table. The class covered relational-database concepts including primary and foreign keys, relationship cardinality, normalisation, denormalisation, star schemas and snowflake schemas. It distinguished online transaction processing (OLTP) databases, which are designed for transaction writing, from online analytical processing (OLAP) databases, which are designed for analytical reading, and linked the transformation between them to extract, transform and load (ETL) processes. The session also introduced DAX measures, filter context, Power Pivot tables, and the differing roles of Excel and Power BI for reporting.

The session developed a darts-scoring challenge by reshaping raw game data into a long table containing game, player, turn, throw and score information. It covered using Power Query to unpivot data, split score strings, merge lookup tables and prepare data before applying game rules in the worksheet with running totals and indicator columns for new turns, wins and losses. The class also reviewed report design and compared histogram outputs, focusing on informative titles, clear axes, precision, white space and information density. The later section introduced VBA, including modules, procedures, object hierarchies, properties, methods, variables, data types, scope, the Visual Basic Editor, and executing or debugging code with F5 and F8.

The session introduced the role of a Power BI data analyst and the overall workflow of preparing, modelling, visualising, analysing and managing data. It explained how data can be drawn from sources such as SQL Server databases, comma-separated values (CSV) files, cloud services and business applications, and distinguished between importing data locally and using DirectQuery. Students practised configuring regional settings, restoring a sample database, and loading six database tables plus two CSV tables into Power BI Desktop. The class also demonstrated Power Query features for checking data quality, handling errors, blanks and duplicates, changing data types, renaming or removing columns, merging columns, creating calculated columns, and applying or reversing transformation steps. Relationships between tables, including one-to-many and many-to-many relationships, were introduced as the basis for later report and dashboard design.

The session reviewed Power BI data modelling, including creating and editing relationships, managing active and inactive links, and hiding intermediary tables used to support many-to-many relationships. It explained filter direction in relationships and the need to avoid ambiguous filtering paths in a data model. Students compared predefined quick measures with custom measures and calculated columns written in Data Analysis Expressions (DAX). Basic DAX syntax was demonstrated for constants, column references, arithmetic calculations, aggregate functions and names containing spaces, alongside setting up financial-year date handling. Students then worked on labs covering model configuration, DAX expressions and date sorting.

The session reviewed Power BI data preparation, including checking data quality, renaming tables and columns, merging columns and tables, removing duplicates and unnecessary fields, changing data types, and using applied steps for troubleshooting. It covered data modelling through one-to-many, many-to-one and many-to-many relationships, including bridge tables, active or inactive relationships, and filter propagation directions. The class also discussed quick measures, custom DAX measures, calculated tables and columns, financial date tables, CALCULATE, REMOVEFILTERS and time-intelligence functions. The main focus then moved to report design: selecting and formatting visualisations, using cards, tables, maps and charts, applying filters and slicers, and planning interactive report layouts. Students began a lab activity to create the first part of a multi-page report.

The session reviewed the Power BI workflow: loading data, cleaning and transforming it, managing columns and recorded query steps, and modelling relationships between tables. It covered DAX calculated columns, measures and tables, financial date tables, filter direction, and report design features including visuals, slicers, drill-through, conditional formatting, synchronised slicers, bookmarks and buttons. Students continued a practical exercise on report design and publishing work to the Power BI service. The new topic introduced dashboards: pinning visuals from reports, combining content from different reports, adding images and titles, using natural-language Q&A, viewing refresh times, and understanding gateways for refreshing on-premises data.

Customer targeting introduced decisions about products, prices, channels and promotion. Market research and statistical methods were considered alongside predictive models, including trees, logistic models and neural networks. Demonstrations used visual analysis, dashboards and models of organic-product purchasing. Age, purchasing frequency, recency and spending illustrated possible customer information. The session also considered production constraints such as performance, traceability, security and compliance, keeping the comparison of models connected to the setting in which their predictions might be used.

Data strategy, architecture, governance and staffing framed the financial-analysis work. The class discussed targeted applications and the limits of broad claims about generative artificial intelligence. Activities compared companies through profitability, liquidity, solvency and cash-flow indicators across several industries. Segmentation and dashboards supported credit and portfolio discussions. Non-linear models, feature importance and scenarios then introduced default-risk analysis with incomplete financial and economic information, including initial feature selection rather than an asserted finished underwriting system or validated lending outcome.

Maintenance was examined through availability, reliability, safety and cost across industrial equipment, buildings, transport and software. Historical and systems-engineering approaches introduced lifecycle support and continuous improvement. The class distinguished operational maintenance from security maintenance and compared preventive and corrective approaches. Systematic, condition-based and predictive work sat alongside temporary and permanent repairs. Inspections, documentation and evaluation were considered with the risk of over-maintenance, making the discussion about choosing an appropriate intervention rather than assuming more maintenance is always better.

Mean time between failures and mean time to repair introduced calculations of reliability and availability. The class considered how equipment behaviour changes across its lifecycle. Five Whys, Pareto analysis and the Maxer method provided approaches to causes and priorities. Computerised maintenance management systems brought together assets, work orders, spares and history. Their integration with enterprise resource planning connected maintenance records with financial and production information, extending the session beyond isolated calculations to the systems that support operational decisions.

Environmental risk was examined through hazards, likelihood, consequences, mitigation and monitoring. Natural processes, climate, pollution, biodiversity and human activity were considered as interconnected rather than separate categories. Videos and discussion introduced impact assessment, risk matrices, waste and wastewater. Unequal exposure and the costs of poor air quality and climate effects broadened the analysis beyond technical measures alone. Citizen science concerning invasive species provided another example of gathering information, while the session retained attention to both local and wider consequences.

The session introduced customer relationship management (CRM) data modelling in Dataverse, including tables, primary and foreign keys, and one-to-many, many-to-one and many-to-many relationships. It compared on-premises and cloud CRM deployments, and covered Dataverse features such as application programming interfaces (APIs), security, auditing, business rules, workflows, duplicate detection, reporting and integrations. Students learnt how development, test and production environments are managed, including environment types, access groups, backup, copying and solution deployment. Practical activities involved accessing a shared CRM environment, creating account and contact records, creating a solution with a publisher and prefix, and creating, publishing and testing a custom table. The session also explained table ownership, activity tables, virtual tables, auditing, quick create forms and record management.

The session began with a practical exercise in exporting account data to Excel, amending a phone number, importing the file back into the CRM system, and checking that the change had been applied. It then covered Dataverse security, including business units, security roles, record privileges, access levels, teams, column-level security and hierarchy security. Further topics included environment analytics, storage capacity, auditing, duplicate detection, bulk deletion and long-term data retention. The class also introduced model-driven, canvas and Power Pages applications, before practising the creation of a model-driven app with grouped tables for customer and sales functions.

The session covered testing and troubleshooting Power Automate flows using Flow Checker, test runs, run history, action statuses and error details. It also explained administrative tasks such as monitoring flow activity, reviewing run histories and sharing flows with appropriate permissions. Business rules were introduced as a no-code way to apply conditions and actions, including showing, hiding, enabling, disabling or requiring form fields, with a practical exercise to control four contact fields according to whether an account had been selected. The class then introduced business process flows as stage-based guides for users, including their steps, limits, associated tables, conditional branches and use in opportunity management.

The session explained the CRM sales pipeline, from creating leads through imports, website forms or direct contact, to recording follow-up activities such as calls, emails, meetings and tasks. Leads can be qualified to create account, contact and opportunity records, or disqualified with a recorded reason while remaining available for later reactivation. Opportunities use price lists and product line items to calculate prices and totals, then progress through quotes, orders, fulfilment, payment and invoicing. The class also distinguished system-generated record IDs from customer-facing quote and order numbers, discussing uniqueness and restrictions on changes after creation. A practical activity asked students to carry out both a successful sales-pipeline case and a disqualified-lead case in the Sales Hub application.