diff --git a/docs/model1/arduino-set-up/flash-arduino.md b/docs/model1/arduino-set-up/flash-arduino.md
new file mode 100644
index 0000000..f789a57
--- /dev/null
+++ b/docs/model1/arduino-set-up/flash-arduino.md
@@ -0,0 +1,129 @@
+# Flash Arduino with SCPI Firmware
+
+This tutorial will guide you through flashing your Arduino with SCPI (Standard Commands for Programmable Instruments) firmware, enabling it to communicate with your EPICS IOC through standardized serial commands.
+
+## Prerequisites
+
+- Completed [Create and Run a Simple EPICS IOC](../create-simple-ioc.md)
+- Arduino device (Uno, Nano, or compatible)
+- USB cable for Arduino connection
+- Computer with Arduino IDE capability
+
+## Required Downloads
+
+First, we need to ensure that our Arduino's are flashed with the correct Arduino files and you must have the Arduino IDE downloaded.
+
+### 1. Arduino SCPI Firmware
+Download the Arduino SCPI firmware files from the GitHub repository:
+- **Repository**: [Link to GitHub repository here]
+- **File needed**: `.ino` file containing the SCPI implementation
+- Save this file to a known location on your computer
+
+### 2. Arduino IDE
+Download and install the Arduino IDE:
+- **Official Download**: [Link to Arduino IDE here]
+- Choose the version appropriate for your operating system
+- Install following the standard installation process
+
+## Step 1: Setup Arduino IDE and Open Firmware
+
+Once those two are downloaded:
+
+1. **Open Arduino IDE**: Launch the Arduino IDE application
+2. **Open SCPI Firmware**: 
+   - Open the `.ino` file that you downloaded from the GitHub repository
+   - Go to `File` → `Open`
+   - Navigate to and select the downloaded `.ino` file
+   - The SCPI firmware code should now be displayed in the IDE
+
+## Step 2: Configure Arduino Connection
+
+Once you've done that:
+
+1. **Connect Arduino**: Plug in your Arduino to your computer using a USB cable
+2. **Select Arduino in IDE**: 
+   - Go to `Tools` → `Board` → `Arduino AVR Boards`
+   - Select the type of Arduino it is (e.g., "Arduino Uno", "Arduino Nano")
+3. **Select Port**:
+   - Go to `Tools` → `Port`
+   - Select the port showing your Arduino (typically shows as "Arduino Uno" or similar)
+
+## Step 3: Handle Missing Libraries
+
+Once you've done that you can begin to upload the `.ino` file to the Arduino. Please keep in note you may run into a few errors regarding libraries missing. To fix this:
+
+### Method 1: Library Manager (Recommended)
+1. Go to `Tools` → `Manage Libraries...`
+2. In the Library Manager search box, search for the missing library name
+3. Click "Install" on the appropriate library
+4. Repeat for any additional missing libraries
+
+### Method 2: Manual Installation
+If libraries aren't available through the Library Manager:
+1. Download the required library as a ZIP file
+2. Go to `Sketch` → `Include Library` → `Add .ZIP Library...`
+3. Select the downloaded ZIP file
+4. Restart the Arduino IDE
+
+### Common Required Libraries
+The SCPI firmware typically requires:
+- **Vrekrer_scpi_parser**: For SCPI command parsing
+- **SoftwareSerial**: Usually included with Arduino IDE
+- Additional libraries specific to your hardware setup
+
+## Step 4: Compile and Upload Firmware
+
+1. **Verify Code**: Click the checkmark icon (✓) to compile and check for errors
+2. **Resolve Any Issues**: 
+   - If compilation errors occur, install missing libraries as described above
+   - Check that board and port selections are correct
+3. **Upload Firmware**: Click the arrow icon (→) to upload the firmware to your Arduino
+4. **Monitor Upload**: Watch the status bar for upload progress and completion
+
+## Step 5: Verify Successful Flash
+
+### Check Upload Confirmation
+- Look for "Done uploading" message in the IDE status area
+- The Arduino's built-in LED may blink during upload
+
+### Test Serial Communication
+1. **Open Serial Monitor**: 
+   - Go to `Tools` → `Serial Monitor`
+   - Set baud rate to match your firmware (typically 9600 or 115200)
+2. **Test SCPI Commands**:
+   - Type `*IDN?` and press Enter
+   - You should receive an identification response from the Arduino
+   - Try other basic SCPI commands as defined in your firmware
+
+## Troubleshooting
+
+### Upload Fails
+- **Port Issues**: Ensure correct port is selected and Arduino is properly connected
+- **Driver Problems**: Install Arduino drivers if port doesn't appear
+- **Board Selection**: Verify correct Arduino model is selected
+
+### Compilation Errors
+- **Missing Libraries**: Install all required libraries through Library Manager
+- **Version Conflicts**: Ensure library versions are compatible
+- **Code Issues**: Verify you have the correct `.ino` file version
+
+### No Serial Response
+- **Baud Rate**: Check serial monitor baud rate matches firmware setting
+- **Connection**: Verify USB cable provides data connection, not just power
+- **Firmware Issues**: Try re-uploading the firmware
+
+## Success Confirmation
+
+Your Arduino is successfully flashed when:
+- Upload completes without errors
+- Serial monitor shows response to `*IDN?` command
+- Arduino responds to basic SCPI commands
+- No error messages in serial communication
+
+## Next Steps
+
+With your Arduino now running SCPI firmware, you're ready to configure serial communication:
+
+**Next tutorial:** [Configure Serial Port Communication](../arduino-set-up/serial-port-communication.md) - Set up serial communication between your Raspberry Pi and Arduino
+
+This will enable your EPICS IOC to send commands to and receive data from your Arduino device through standardized SCPI protocols.
\ No newline at end of file
diff --git a/docs/model1/arduino-set-up/serial-port-communication.md b/docs/model1/arduino-set-up/serial-port-communication.md
new file mode 100644
index 0000000..5f95afd
--- /dev/null
+++ b/docs/model1/arduino-set-up/serial-port-communication.md
@@ -0,0 +1,343 @@
+# Configure Serial Port Communication
+
+This tutorial shows you how to set up serial communication between your Raspberry Pi EPICS IOC and your Arduino with SCPI firmware, enabling command and data exchange between the systems.
+
+## Prerequisites
+
+- Completed [Flash Arduino with SCPI Firmware](../arduino-scpi-firmware.md)
+- Arduino running SCPI firmware and responding to `*IDN?` commands
+- EPICS IOC environment set up on Raspberry Pi
+- ASYN and StreamDevice modules installed
+- USB cable connecting Arduino to Raspberry Pi
+
+## Overview
+
+The communication setup involves:
+1. **Physical Connection**: USB cable between Arduino and Raspberry Pi
+2. **Serial Port Configuration**: Setting up the Linux serial port
+3. **ASYN Driver Setup**: Configuring EPICS ASYN for serial communication
+4. **StreamDevice Protocol**: Creating protocol files for SCPI commands
+5. **Database Records**: Setting up EPICS database records for device interaction
+
+## Step 1: Identify Serial Port
+
+### Connect Arduino and Find Port
+1. **Connect Arduino**: Plug Arduino into Raspberry Pi via USB
+2. **Check Available Ports**: 
+   ```bash
+   ls /dev/tty*
+   ```
+   Look for devices like `/dev/ttyUSB0`, `/dev/ttyACM0`, or similar
+3. **Verify Arduino Connection**:
+   ```bash
+   dmesg | tail
+   ```
+   Should show USB device connection messages
+
+### Test Serial Communication
+1. **Install Serial Tools** (if not already installed):
+   ```bash
+   sudo apt-get install screen minicom
+   ```
+2. **Test Direct Communication**:
+   ```bash
+   screen /dev/ttyUSB0 9600
+   ```
+   - Type `*IDN?` and press Enter
+   - You should see Arduino's identification response
+   - Exit screen with `Ctrl+A` then `K`
+
+## Step 2: Configure EPICS ASYN Serial Port
+
+### Create Serial Port Configuration
+In your EPICS IOC startup script (typically `st.cmd`), add the serial port configuration:
+
+```bash
+################################################################################
+# Serial Port Configuration for Arduino SCPI
+################################################################################
+
+# Configure serial port - adjust device path as needed
+drvAsynSerialPortConfigure("ARDUINO", "/dev/ttyUSB0", 0, 0, 0)
+
+# Set serial communication parameters
+asynSetOption("ARDUINO", -1, "baud", "9600")
+asynSetOption("ARDUINO", -1, "bits", "8") 
+asynSetOption("ARDUINO", -1, "parity", "none")
+asynSetOption("ARDUINO", -1, "stop", "1")
+asynSetOption("ARDUINO", -1, "clocal", "Y")
+asynSetOption("ARDUINO", -1, "crtscts", "N")
+
+# Set input/output terminators
+asynOctetSetInputEos("ARDUINO", -1, "\n")
+asynOctetSetOutputEos("ARDUINO", -1, "\n")
+
+# Enable communication tracing (optional - for debugging)
+asynSetTraceIOMask("ARDUINO", -1, 0x2)
+asynSetTraceMask("ARDUINO", -1, 0x9)
+```
+
+### Configuration Parameters Explained
+- **Port Name**: `"ARDUINO"` - logical name for your serial port
+- **Device Path**: `"/dev/ttyUSB0"` - physical serial device (adjust as needed)
+- **Baud Rate**: `"9600"` - must match Arduino firmware settings
+- **Data Bits**: `"8"` - standard for most serial communication
+- **Parity**: `"none"` - no parity checking
+- **Stop Bits**: `"1"` - single stop bit
+- **Flow Control**: `"crtscts", "N"` - no hardware flow control
+- **Terminators**: `"\n"` - newline characters to mark end of messages
+
+## Step 3: Create StreamDevice Protocol File
+
+### Create Protocol File
+Create a file named `arduino_scpi.proto` in your IOC's `db/` directory:
+
+```
+################################################################################
+# Arduino SCPI Protocol File
+# File: arduino_scpi.proto
+################################################################################
+
+# Terminator for all commands
+Terminator = "\n";
+
+# Get identification string
+getIDN {
+    out "*IDN?";
+    in "%39c";
+    ExtraInput = Ignore;
+}
+
+# Generic digital output control
+setDigitalOut {
+    out "OUTP:DIG %d,%d";
+    @init { getDigitalOut; }
+}
+
+# Read digital output status  
+getDigitalOut {
+    out "OUTP:DIG? %d";
+    in "%d";
+    ExtraInput = Ignore;
+}
+
+# Set analog output voltage
+setAnalogOut {
+    out "SOUR:VOLT %f,%d";
+    @init { getAnalogOut; }
+}
+
+# Read analog output voltage
+getAnalogOut {
+    out "SOUR:VOLT? %d";
+    in "%f";
+    ExtraInput = Ignore;
+}
+
+# Read analog input voltage
+getAnalogIn {
+    out "MEAS:VOLT? %d";
+    in "%f";
+    ExtraInput = Ignore;
+}
+
+# Read digital input status
+getDigitalIn {
+    out "MEAS:DIG? %d";
+    in "%d";
+    ExtraInput = Ignore;
+}
+
+# System reset
+systemReset {
+    out "*RST";
+}
+
+# System status
+getSystemStatus {
+    out "*STB?";
+    in "%d";
+    ExtraInput = Ignore;
+}
+```
+
+### Protocol File Notes
+- **Terminator**: Defines message ending character
+- **ExtraInput = Ignore**: Handles any extra characters from device
+- **@init**: Executes initialization commands when record starts
+- **Format Specifiers**: `%d` for integers, `%f` for floats, `%c` for characters
+
+## Step 4: Create EPICS Database Records
+
+### Create Database File
+Create `arduino_scpi.db` in your IOC's `db/` directory:
+
+```
+################################################################################
+# Arduino SCPI Database Records
+# File: arduino_scpi.db
+################################################################################
+
+# Device identification
+record(waveform, "$(P)$(R)IDN_RBV") {
+    field(DESC, "Device identification")
+    field(DTYP, "stream")
+    field(INP,  "@arduino_scpi.proto getIDN $(PORT)")
+    field(FTVL, "CHAR")
+    field(NELM, "40")
+    field(PINI, "YES")
+}
+
+# Digital Output Control (Pin 13 - LED)
+record(bo, "$(P)$(R)LED") {
+    field(DESC, "Arduino LED Control")
+    field(DTYP, "stream") 
+    field(OUT,  "@arduino_scpi.proto setDigitalOut(13) $(PORT)")
+    field(ZNAM, "OFF")
+    field(ONAM, "ON")
+}
+
+record(bi, "$(P)$(R)LED_RBV") {
+    field(DESC, "Arduino LED Status")
+    field(DTYP, "stream")
+    field(INP,  "@arduino_scpi.proto getDigitalOut(13) $(PORT)")
+    field(ZNAM, "OFF")
+    field(ONAM, "ON")
+    field(SCAN, "2 second")
+}
+
+# Analog Input Reading (A0)
+record(ai, "$(P)$(R)AIN0") {
+    field(DESC, "Analog Input 0")
+    field(DTYP, "stream")
+    field(INP,  "@arduino_scpi.proto getAnalogIn(0) $(PORT)")
+    field(EGU,  "V")
+    field(PREC, "3")
+    field(SCAN, "1 second")
+}
+
+# Analog Output Control (if available)
+record(ao, "$(P)$(R)AOUT0") {
+    field(DESC, "Analog Output 0") 
+    field(DTYP, "stream")
+    field(OUT,  "@arduino_scpi.proto setAnalogOut(0) $(PORT)")
+    field(EGU,  "V")
+    field(PREC, "3")
+    field(DRVL, "0")
+    field(DRVH, "5")
+}
+
+record(ai, "$(P)$(R)AOUT0_RBV") {
+    field(DESC, "Analog Output 0 Readback")
+    field(DTYP, "stream") 
+    field(INP,  "@arduino_scpi.proto getAnalogOut(0) $(PORT)")
+    field(EGU,  "V")
+    field(PREC, "3")
+}
+
+# System reset command
+record(bo, "$(P)$(R)RESET") {
+    field(DESC, "System Reset")
+    field(DTYP, "stream")
+    field(OUT,  "@arduino_scpi.proto systemReset $(PORT)")
+}
+```
+
+## Step 5: Update IOC Startup Script
+
+### Modify st.cmd File
+Add these sections to your IOC startup script:
+
+```bash
+################################################################################
+# Load protocol file path
+################################################################################
+epicsEnvSet("STREAM_PROTOCOL_PATH", "$(TOP)/db")
+
+################################################################################
+# Load Arduino database
+################################################################################
+dbLoadRecords("db/arduino_scpi.db", "P=ARDUINO:,R=DEV1:,PORT=ARDUINO")
+
+################################################################################
+# Optional: Load asynRecord for debugging
+################################################################################
+dbLoadRecords("$(ASYN)/db/asynRecord.db", "P=ARDUINO:,R=ASYN,PORT=ARDUINO,ADDR=0,OMAX=80,IMAX=80")
+```
+
+## Step 6: Test the Configuration
+
+### Start the IOC
+1. **Navigate to IOC directory**:
+   ```bash
+   cd /path/to/your/ioc/iocBoot/iocYourIOC
+   ```
+2. **Start IOC**:
+   ```bash
+   ./st.cmd
+   ```
+3. **Look for successful initialization messages**:
+   - Serial port configuration
+   - Database loading
+   - Arduino identification response
+
+### Test Communication
+From the IOC console, test basic commands:
+
+```bash
+# Check device identification
+dbpr ARDUINO:DEV1:IDN_RBV
+
+# Control LED
+caput ARDUINO:DEV1:LED 1    # Turn on
+caput ARDUINO:DEV1:LED 0    # Turn off
+
+# Read analog input
+caget ARDUINO:DEV1:AIN0
+
+# Check LED status
+caget ARDUINO:DEV1:LED_RBV
+```
+
+## Step 7: Troubleshooting
+
+### Serial Communication Issues
+- **Port not found**: Check `/dev/tty*` devices and adjust path
+- **Permission denied**: Add user to dialout group: `sudo usermod -a -G dialout $USER`
+- **No response**: Verify baud rate matches Arduino firmware
+- **Garbled output**: Check terminator settings and flow control
+
+### EPICS Configuration Issues
+- **Protocol not found**: Verify `STREAM_PROTOCOL_PATH` setting
+- **Record errors**: Check protocol file syntax and record field names
+- **Database loading fails**: Verify file paths and macro substitutions
+
+### Debugging Tools
+1. **Enable ASYN tracing** (in st.cmd):
+   ```bash
+   asynSetTraceMask("ARDUINO", -1, 0x11)    # Error + Flow
+   asynSetTraceIOMask("ARDUINO", -1, 0x6)   # Read + Write
+   ```
+
+2. **Use asynRecord screen** for manual testing:
+   ```bash
+   caget -S ARDUINO:ASYN.AINP    # View last input
+   caput ARDUINO:ASYN.AOUT "*IDN?"  # Send manual command
+   ```
+
+## Success Verification
+
+Your serial communication is working when:
+- IOC starts without serial port errors
+- `*IDN?` returns Arduino identification
+- LED control works from EPICS commands
+- Analog readings update automatically
+- No timeout or communication errors in IOC log
+
+## Next Steps
+
+With serial communication established between your EPICS IOC and Arduino, you're ready to understand how this fits into the larger system architecture:
+
+**Next tutorial:** [Architecture of Sidekick Model 1](../model1-architecture.md) - Learn how your Arduino/EPICS setup integrates into the complete distributed control system
+
+This will show you how your Arduino SCPI device works as part of the broader Sidekick demonstration system with multiple components, computers, and network communication working together through EPICS.
\ No newline at end of file
diff --git a/docs/model1/getting-started/1-requirements-and-overview.md b/docs/model1/getting-started/1-requirements-and-overview.md
new file mode 100644
index 0000000..fc395d3
--- /dev/null
+++ b/docs/model1/getting-started/1-requirements-and-overview.md
@@ -0,0 +1,45 @@
+---
+layout: default
+title: Requirements and Overview
+authors:
+    - Elias Dandouch
+    - Scott Feister
+---
+# Getting Started with Raspberry Pi Setup
+
+This guide will walk you through setting up two Raspberry Pi devices with SSH access for remote development. You'll complete hardware setup, network configuration, OS installation, and initial system access.
+
+## Requirements
+
+Before starting, ensure you have the following:
+
+### Hardware Requirements
+- 2x Raspberry Pi devices (Model 3 B+ or newer recommended)
+- 2x MicroSD cards (16GB minimum, Class 10 recommended)
+- 1x MicroSD card USB reader
+- 2x Ethernet cables
+- 1x Personal computer/laptop
+- Power supplies for both Raspberry Pi devices
+- Access to a wired or wireless router with internet connection
+
+### Software Requirements
+- Administrative access to your router's configuration page
+- Basic familiarity with SSH connections
+- Raspberry Pi OS Imager software
+
+### Network Access
+- Administrative login credentials for your wireless/wired router
+- Internet connection for downloading updates
+
+## Completion Criteria
+
+You will know you have successfully completed this setup when:
+
+1. **Hardware/Ethernet Setup**: Both Raspberry Pis are physically connected to your network via Ethernet cables
+2. **WiFi Configuration** (Optional): Devices can connect via WiFi as backup/alternative
+3. **SSH and Flashing**: Both Pi devices are flashed with OS and accessible via SSH from your laptop
+4. **System Updates**: Both devices are fully up-to-date with the latest software packages
+
+---
+
+
diff --git a/docs/model1/getting-started/2-hardware-ethernet-setup.md b/docs/model1/getting-started/2-hardware-ethernet-setup.md
new file mode 100644
index 0000000..475ec82
--- /dev/null
+++ b/docs/model1/getting-started/2-hardware-ethernet-setup.md
@@ -0,0 +1,51 @@
+---
+layout: default
+title: Hardware Ethernet Setup
+authors:
+    - Elias Dandouch
+    - Scott Feister
+---
+# Step 1: Hardware / Ethernet Setup (10 minutes)
+
+### Physical Connection Setup
+Before flashing your SD cards, let's establish the physical network infrastructure:
+
+1. **Router Connection**: Ensure your router/switch has at least 2 available Ethernet ports
+2. **Cable Preparation**: Have both Ethernet cables ready - you'll connect these after the Pi devices boot
+3. **Power Supply Check**: Verify both Pi power supplies are functional
+4. **Network Planning**: Note your router's IP range (typically 192.168.1.x or 192.168.0.x)
+
+### Router Access Verification
+1. Access your [router's administrative panel](https://www.lifewire.com/accessing-your-router-at-home-818205)
+2. Navigate to the "Connected Devices" or "DHCP Clients" section
+3. Familiarize yourself with the interface - you'll use this to find your Pi devices later
+
+**Why Ethernet First?**: Ethernet provides the most reliable initial connection. Once SSH is established, you can configure WiFi as needed.
+
+### macOS Network Priority Issue
+
+**Problem**: If you're using macOS, your Mac will always prioritize direct Ethernet connections even when they don't provide internet access. This can be frustrating when you need internet access while SSH'd into your Pi devices.
+
+**Solution**: Reorder your network service priorities to prioritize WiFi over Ethernet adapters.
+
+**Step 1**: Check current network priority:
+```bash
+networksetup -listnetworkserviceorder
+```
+
+**Step 2**: Identify the problem - if you see Ethernet adapters (like AX88179A) listed before WiFi, this will cause the issue.
+
+**Step 3**: Reorder services to prioritize WiFi:
+```bash
+sudo networksetup -ordernetworkservices "Wi-Fi" "AX88179A" "TI_AM335x_BeagleBone_Black" "Thunderbolt Bridge" "iPhone USB"
+```
+*Note: Adjust the service names to match your specific output from Step 1.*
+
+**Step 4**: Verify the change:
+```bash
+networksetup -listnetworkserviceorder
+```
+
+WiFi should now appear as priority (1) in the list. You can now connect Ethernet cables to your Pi devices without losing internet access on your Mac.
+
+---
diff --git a/docs/model1/getting-started/3-wifi-configuration.md b/docs/model1/getting-started/3-wifi-configuration.md
new file mode 100644
index 0000000..5a93812
--- /dev/null
+++ b/docs/model1/getting-started/3-wifi-configuration.md
@@ -0,0 +1,24 @@
+---
+layout: default
+title: WiFi Configuration (Optional)
+authors:
+    - Elias Dandouch
+    - Scott Feister
+---
+# Step 2: WiFi Configuration (Optional - 5 minutes)
+
+While Ethernet is recommended for initial setup, you can configure WiFi during the OS imaging process:
+
+### During OS Imaging (Recommended)
+- Configure WiFi credentials in the Raspberry Pi Imager's "Advanced Options"
+- This allows WiFi as a backup if Ethernet fails
+- Useful for portable setups or locations without available Ethernet ports
+
+### After Initial Setup (Alternative)
+- Connect via Ethernet first, then configure WiFi through SSH
+- Edit `/etc/wpa_supplicant/wpa_supplicant.conf` manually
+- More complex but provides flexibility for network changes
+
+**Note**: For this tutorial, we'll primarily use Ethernet for reliability, with WiFi as optional backup.
+
+---
\ No newline at end of file
diff --git a/docs/model1/getting-started/4-ssh-and-flashing.md b/docs/model1/getting-started/4-ssh-and-flashing.md
new file mode 100644
index 0000000..b010be8
--- /dev/null
+++ b/docs/model1/getting-started/4-ssh-and-flashing.md
@@ -0,0 +1,122 @@
+---
+layout: default
+title: SSH & Flashing into the PIs
+authors:
+ - Elias Dandouch
+ - Scott Feister
+---
+
+# Step 3: SSH and Flash Raspberry Pi Devices (30 minutes per device)
+
+### Part A: Flash the First Pi (15 minutes)
+
+#### Prepare SD Card and Imager
+1. Insert microSD card into your computer via USB reader
+2. Download and install [Raspberry Pi OS Imager](https://www.raspberrypi.com/software/)
+3. Open the imager software
+
+#### Configure OS Settings
+1. **Operating System**: Click "CHOOSE OS" → "Raspberry Pi OS (other)" → "Raspberry Pi OS Lite"
+2. **Storage**: Click "CHOOSE STORAGE" and select your microSD card
+3. **Advanced Options**: Press "CTRL + SHIFT + X" or click the gear icon
+
+#### Advanced Configuration (Required)
+Configure these settings in the Advanced Options window:
+
+**Essential Settings:**
+- **Hostname**: Set to "epics1.local" (unique identifier)
+- **Enable SSH**: Check box and set a secure password
+- **Username**: Keep as "pi" or set custom username
+- **Set locale settings**: Configure timezone, check "Skip first run wizard"
+
+**Optional WiFi Settings:**
+- **WiFi SSID**: Your network name
+- **WiFi Password**: Network password
+- **WiFi Country**: Your country code
+
+Click "Save" then "Write" to flash the card.
+
+#### Boot and Network Connection
+1. Insert flashed SD card into first Raspberry Pi
+2. Connect Ethernet cable between Pi and router
+3. Connect power cable - Pi will boot automatically
+4. Wait 3-5 minutes for initial boot process
+
+### Part B: Establish SSH Connection (10 minutes)
+
+#### Locate Pi on Network
+1. Access your router's admin panel
+2. Look for "epics1" in connected devices list
+3. Note the assigned IP address (e.g., 192.168.1.100)
+
+#### Connect via SSH
+**Linux/macOS:**
+```bash
+ssh pi@192.168.1.100
+```
+
+**Windows (PowerShell):**
+```bash
+ssh pi@192.168.1.100
+```
+
+**Windows (PuTTY):**
+- Host: 192.168.1.100
+- Username: pi
+- Password: [your set password]
+
+#### Verify Connection
+Successful connection shows:
+```bash
+pi@epics1:~ $
+```
+
+#### Update System
+```bash
+sudo apt -y update
+sudo apt -y upgrade
+```
+*This process takes 15-20 minutes on first boot.*
+
+### Part C: Repeat for Second Pi (15 minutes)
+
+Follow the same process for your second Pi with these changes:
+- **Hostname**: Set to "epics2.local"
+- **Different SD Card**: Use your second microSD card
+- **Second Ethernet Port**: Connect to different router port
+- **Unique IP**: Router will assign different IP address
+
+## Test Communication Between Your Pis
+
+Once both devices are set up and accessible via SSH, verify they can communicate with each other:
+
+**From Pi 1 (epics1), test connection to Pi 2:**
+```bash
+ssh pi@epics2.local
+# Or use the IP address directly:
+ssh pi@[EPICS2_IP_ADDRESS]
+```
+
+**From Pi 2 (epics2), test connection to Pi 1:**
+```bash
+ssh pi@epics1.local
+# Or use the IP address directly:
+ssh pi@[EPICS1_IP_ADDRESS]
+```
+
+**Test network connectivity:**
+```bash
+# From either Pi, ping the other:
+ping epics1.local
+ping epics2.local
+```
+
+When you can successfully SSH between your Pi devices and see successful ping responses, you have achieved the goal of this module: **your Raspberry Pi devices can now communicate with each other**.
+
+## Next Steps
+
+With both Raspberry Pi devices successfully set up with SSH access and inter-Pi communication established, you're ready to proceed with building your EPICS development environment:
+
+**Next tutorial:** [Install EPICS v7](../simple-ioc/pi-epics-install.md) - Install and configure the EPICS framework on both Pi devices
+
+This will transform your networked Pi setup into a functional EPICS distribute
\ No newline at end of file
diff --git a/docs/model1/model1-architecture.md b/docs/model1/model1-architecture.md
index f932763..67ae399 100644
--- a/docs/model1/model1-architecture.md
+++ b/docs/model1/model1-architecture.md
@@ -1,10 +1,3 @@
----
-layout: default
-title: Architecture
-authors:
-    - Scott Feister
----
-
 # Architecture of Sidekick Model 1
 
 Sidekick Model 1 is designed to be inexpensive, easy to understand, and easy to build. It incorporates a motorized element. It's a great way to get your first experience with EPICS.
@@ -27,4 +20,13 @@ The Sidekick Model 1 demo consists of:
 All components work together thanks to EPICS, which runs on all the computers in the system. The workload of control, acquisition, analysis, and visualization is distributed.
 
 ## Interaction Between Components
-[![](https://mermaid.ink/img/pako:eNqVVU2PmzAU_CuWc00OgUvFVpXagCBS1KAl2wvswTWmoAJGxnQbbfa_95mPQICkSQ6RM_NmsMePl3dMeciwgaOUv9GYCIkOZpAj-NCUlKXJIkR5VqAoSVNjwai-LKXgv5mx0PVuvXpLQhkbWvH3aSQlIqxa6fpBacJppxSPKQWvJBOtOBKfHhKnpJC8O24UafeIy-rnL0GKGJnWj51lIt9kfxLKDAQ_ytemhuXhtNhzXvpiL64k7PtWvWv35W6VlgzZLGeCSH5b5uwHuphLuHLJ6C2V5W433hr5G7h7laaBWJHQct0K1Ge737i27_FIwur-_dTO2sRZu3SG5HrrQYwtDcH19P-Cq5-oT56oj87i7AeHuSuk3VdXRZQmLJdo1zTOYhiRKlj77lHGPDdQcayfe8tOm9hpIzvtAbvvyFdfz_X7MKxrlm23fl6tvpxevG-nNvczqbrzggTgTEIrXnCu3VPQbpecs2_Itqtq0jo4J7XHAaNdZfQ5po5_Hp91anat8MPz1j6157_KnXc9w9VJDCZHl6Wad08jXMU4h4PnLAzpTfDmZtRMHMPKfQYG8zkUvMdweydqyE9x7QquT3HVac3kHcFwSc1QHeNaj-MlzpjISBLCX9G7qguwjFnGAmzAMmQRqVIZ4CD_gNKqCIlkVpjAy4mNiMDgWWJSSe4dc4oNKSrWFZkJgbcha6s-_gFeJSL8)](https://mermaid.live/edit#pako:eNqVVU2PmzAU_CuWc00OgUvFVpXagCBS1KAl2wvswTWmoAJGxnQbbfa_95mPQICkSQ6RM_NmsMePl3dMeciwgaOUv9GYCIkOZpAj-NCUlKXJIkR5VqAoSVNjwai-LKXgv5mx0PVuvXpLQhkbWvH3aSQlIqxa6fpBacJppxSPKQWvJBOtOBKfHhKnpJC8O24UafeIy-rnL0GKGJnWj51lIt9kfxLKDAQ_ytemhuXhtNhzXvpiL64k7PtWvWv35W6VlgzZLGeCSH5b5uwHuphLuHLJ6C2V5W433hr5G7h7laaBWJHQct0K1Ge737i27_FIwur-_dTO2sRZu3SG5HrrQYwtDcH19P-Cq5-oT56oj87i7AeHuSuk3VdXRZQmLJdo1zTOYhiRKlj77lHGPDdQcayfe8tOm9hpIzvtAbvvyFdfz_X7MKxrlm23fl6tvpxevG-nNvczqbrzggTgTEIrXnCu3VPQbpecs2_Itqtq0jo4J7XHAaNdZfQ5po5_Hp91anat8MPz1j6157_KnXc9w9VJDCZHl6Wad08jXMU4h4PnLAzpTfDmZtRMHMPKfQYG8zkUvMdweydqyE9x7QquT3HVac3kHcFwSc1QHeNaj-MlzpjISBLCX9G7qguwjFnGAmzAMmQRqVIZ4CD_gNKqCIlkVpjAy4mNiMDgWWJSSe4dc4oNKSrWFZkJgbcha6s-_gFeJSL8)
+
+[![](https://mermaid.ink/img/pako:eNqVVU2PmzAU_CuWc00OgUvFVpXagCBS1KAl2wvswTWmoAJGxnQbbfa_95mPQICkSQ6RM_NmsMePl3dMeciwgaOUv9GYCIkOZpAj-NCUlKXJIkR5VqAoSVNjwai-LKXgv5mx0PVuvXpLQhkbWvH3aSQlIqxa6fpBacJppxSPKQWvJBOtOBKfHhKnpJC8O24UafeIy-rnL0GKGJnWj51lIt9kfxLKDAQ_ytemhuXhtNhzXvpiL64k7PtWvWv35W6VlgzZLGeCSH5b5uwHuphLuHLJ6C2V5W433hr5G7h7laaBWJHQct0K1Ge737i27_FIwur-_dTO2sRZu3SG5HrrQYwtDcH19P-Cq5-oT56oj87i7AeHuSuk3VdXRZQmLJdo1zTOYhiRKlj77lHGPDdQcayfe8tOm9hpIzvtAbvvyFdfz_X7MKxrlm23fl6tvpxevG-nNvczqbrzggTgTEIrXnCu3VPQbpecs2_Itqtq0jo4J7XHAaNdZfQ5po5_Hp91anat8MPz1j6157_KnXc9w9VJDCZHl6Wad08jXMU4h4PnLAzpTfDmZtRMHMPKfQYG8zkUvMdweydqyE9x7QquT3HVac3kHcFwSc1QHeNaj-MlzpjISBLCX9G7qguwjFnGAmzAMmQRqVIZ4CD_gNKqCIlkVpjAy4mNiMDgWWJSSe4dc4oNKSrWFZkJgbcha6s-_gFeJSL8)](https://mermaid.live/edit#pako:eNqVVU2PmzAU_CuWc00OgUvFVpXagCBS1KAl2wvswTWmoAJGxnQbbfa_95mPQICkSQ6RM_NmsMePl3dMeciwgaOUv9GYCIkOZpAj-DCUlKXJIkR5VqAoSVNjwai-LKXgv5mx0PVuvXpLQhkbWvH3aSQlIqxa6fpBacJppxSPKQWvJBOtOBKfHhKnpJC8O24UafeIy-rnL0GKGJnWj51lIt9kfxLKDAQ_ytemhuXhtNhzXvpiL64k7PtWvWv35W6VlgzZLGeCSH5b5uwHuphLuHLJ6C2V5W433hr5G7h7laaBWJHQct0K1Ge737i27_FIwur-_dTO2sRZu3SG5HrrQYwtDcH19P-Cq5-oT56oj87i7AeHuSuk3VdXRZQmLJdo1zTOYhiRKlj77lHGPDdQcayfe8tOm9hpIzvtAbvvyFdfz_X7MKxrlm23fl6tvpxevG-nNvczqbrzggTgTEIrXnCu3VPQbpecs2_Itqtq0jo4J7XHAaNdZfQ5po5_Hp91anat8MPz1j6157_KnXc9w9VJDCZHl6Wad08jXMU4h4PnLAzpTfDmZtRMHMPKfQYG8zkUvMdweydqyE9x7QquT3HVac3kHcFwSc1QHeNaj-MlzpjISBLCX9G7qguwjFnGAmzAMmQRqVIZ4CD_gNKqCIlkVpjAy4mNiMDgWWJSSe4dc4oNKSrWFZkJgbcha6s-_gFeJSL8)
+
+## Next Steps
+
+Now that you understand the architecture of the Sidekick Model 1 system, you can access all the source components needed to build your own:
+
+**Next tutorial:** [Source Components](../model1/model1-source-components.md) - Access Arduino firmware, IOC configuration files, CAD files, and bill of materials
+
+This provides all the downloadable resources, GitHub repositories, and documentation needed to replicate the complete Sidekick demonstration system with your own hardware.
\ No newline at end of file
diff --git a/docs/model1/pi-first-boot.md b/docs/model1/pi-first-boot.md
deleted file mode 100644
index b30db59..0000000
--- a/docs/model1/pi-first-boot.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# First boot and SSH into your Raspberry Pi (35 minutes)
-You will insert the microSD card you just flashed with Raspberry Pi OS Lite, boot it, SSH into it, and bring it fully up-to-date.
-
-## References
-1. [How to Connect to an SSH Server from Windows, macOS, or Linux](https://www.howtogeek.com/311287/how-to-connect-to-an-ssh-server-from-windows-macos-or-linux/)
-2. [Bringing your Raspberry Pi up-to-date](https://jamesjdavis.medium.com/how-to-update-raspberry-pi-just-follow-these-easy-steps-ac507cf70238)
-
-## Pre-requisites
-* Completion of the tutorial in which you flashed your microSD card for your Raspberry Pi.
-* Familiarity with the method of [SSH remote connection to networked computers](https://www.startutorial.com/articles/view/ssh-basics-part-1-introduction)
-* Administrative login to your wireless/wired router login page (for locating IP addresses of network clients)
-
-## Materials
-* Raspberry Pi (I used a Raspberry Pi 4, but any should work)
-* Flashed microSD card from prior instructions
-* Ethernet cable
-* Wired or wireless router, with internet connection
-* Personal computer
-
-## Steps
-### Boot your Raspberry Pi for the first time (10 minutes)
-1. Insert your finalized microSD card into your Raspberry Pi.
-1. Physically connect your Raspberry Pi to your local area network with an Ethernet cable (or, if you configured the Pi for WiFi during setup, via WiFi).
-1. Connect power to your Raspberry Pi. It will turn on. Give it a few minutes to complete its first boot initialization.
-    
-### Find your Pi on the Network (5 minutes)
-
-You'll need to locate your Raspberry Pi's IP address on your local area network before you can move to the next step.
-
-The simplest way to do this is from your [Wireless/Wired Router's administrative login page](https://www.lifewire.com/accessing-your-router-at-home-818205). From that page, you can see connected devices listed, and within that list, you can locate your Raspberry Pi's IP address.
-
-At this point, it might be nice to assign your Raspberry Pi a fixed IP address from within your Wireless/Wired Router administrative panel. Doing so is outside the scope of this tutorial.
-
-A more advanced way to do this is to perform a Network Scan. This technique is outside the scope of our tutorial.
-
-### SSH into your Pi (5 minutes)
-
-Using your preferred SSH tool, such as [PuTTY](https://www.putty.org/) on Windows, connect with your Raspberry Pi from your personal computer. The username is pi, and the password is as you set in the Raspberry Pi OS Imager settings above.
-
-If you are entirely new to SSH, you may want to follow this tutorial: [How to Connect to an SSH Server from Windows, macOS, or Linux](https://www.howtogeek.com/311287/how-to-connect-to-an-ssh-server-from-windows-macos-or-linux/)
-
-For example, in Linux, you might run: `ssh pi@192.168.202.200`, if your Pi's IP address that you found in the last step were 192.168.202.200. Then, when prompted, you would put in your password that you set in the Raspberry Pi OS Imager step above.
-
-If your terminal window displays a prompt that begins with:
-
-```bash
-pi@epics1$
-```
-
-Congratulations! You are now successfully in a Linux shell running on the Raspberry Pi. You will use this remote shell to modify your Raspberry Pi and install EPICS.
-
-### Bring the OS fully up-to-date (15 minutes)
-From your SSH terminal window, bring all software on the Raspberry Pi fully up-to-date. This is best practice before installing required dependencies. Here's how:
-
-First, ensure your Raspberry Pi has a working internet connection.
-
-Second, optionally, set your correct timezone. Do this by typing `raspi-config` to open a graphical configuration tool, and then set the timezone under the menu item named "Localisation".
-
-Then, bring your Raspberry Pi OS up-to-date:
-
-```bash
-sudo apt -y update
-sudo apt -y upgrade
-```
-
-Note: The `-y` lets you skip typing "yes" to prompts.
-
-Plan for about fifteen minutes of downloading and installing software upgrades on your first boot.
diff --git a/docs/model1/pi-flash.md b/docs/model1/pi-flash.md
deleted file mode 100644
index 04c133d..0000000
--- a/docs/model1/pi-flash.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# Install and configure Raspberry Pi OS Lite on your microSD card (10 minutes)
-In this tutorial, you will flash Raspberry Pi OS Lite on your microSD card in such a way that you can remotely connect to the machine via SSH. This tutorial assumes you will connect the Raspberry Pi to your local network using an Ethernet cable. Instructions for connecting via wifi are linked to, but not described in detail, towards the end.
-
-## Why Pi OS Lite?
-We chose Raspberry Pi OS Lite because it has lower installation size than the Raspberry Pi OS. Since we won't be using any of the Desktop elements of our Raspberry Pi, but will be connecting remotely, we don't need the "extras". This makes it a nice, clean foundation for our EPICS goals.
-
-## References
-1. [Toms Hardware: Raspberry Pi OS Imager Now Comes with Advanced Options](https://www.tomshardware.com/news/raspberry-pi-imager-now-comes-with-advanced-options)
-
-## Materials
-* Raspberry Pi (e.g. this [Raspberry Pi Model 3 B+](https://www.raspberrypi.com/products/raspberry-pi-3-model-b-plus/))
-* Blank MicroSD card (e.g. this [16 GB SanDisk microSD card](https://www.amazon.com/SanDisk-Ultra-SDSQUNS-016G-GN3MN-UHS-I-microSDHC/dp/B074B4P7KD/ref=sr_1_4?dchild=1&keywords=micro+sd+card+16gb&qid=1634232331&s=electronics&sr=1-4)
-* MicroSD card USB reader (e.g. this [Anker USB 3.0 microSD card reader](https://www.raspberrypi.com/software/))
-* Personal computer
-
-## Steps
-### Plug in your SD Card
-Plug your blank microSD card into your personal computer using your USB microSD card reader.
- 
-### Download and Open Raspberry Pi OS Imager
-Download the installer for the [Raspberry Pi OS imager](https://www.raspberrypi.com/software/) onto your laptop.
-
-I used v1.7.1. Once it's downloaded, install the software.
-
-### Configure Basic Settings
-Open the Raspberry Pi OS Imager software on your personal computer. You will complete the next several steps from within Raspberry Pi OS Imager.
-
-From within the Raspberry Pi OS Imager software, click the "Operating System / CHOOSE OS" box, then navigate to "Raspberry Pi OS (other)", and select "Raspberry Pi OS Lite" (a port of Debian with no desktop environment).
-
-![image](https://user-images.githubusercontent.com/7269185/156225778-221f98dd-bbf5-41b3-9d06-3780e2b0556e.png)
-
-Notes:
-
-1. I chose the Lite version to increase performance by omitting a desktop environment, but you could use any version.
-1. When I wrote this tutorial, the Raspberry Pi OS Lite version I used was at "2022-01-08". You can use the latest version, which loads by default.
-
-Back at the main screen of the Raspberry Pi OS imager software, click the "Storage / CHOOSE STORAGE" box, and select your microSD card.
-
-![image](https://user-images.githubusercontent.com/7269185/156225884-8cfe6c37-75a6-4db5-8647-c71a3342bc47.png)
-
-Do NOT click "Write" yet! Instead, press "CTRL + SHIFT + X" or click the gears icon to open the "Advanced options" window.
-
-![image](https://user-images.githubusercontent.com/7269185/156225956-4622466f-6a61-42c9-b482-58f3e0b8418e.png)
-
-### Configure Advanced Options (Required)
-From the "Advanced options" window that opened when you pressed "CTRL + SHIFT + X" or pressed the gears icon, configure the following. (Note, you will need to scroll down in the Advanced Options window or resize the window in order to see all these settings.)
-
-Check the "Set hostname" box and change from "raspberrypi.local" to "epics1.local" (or another unique hostname of your choosing). This is to avoid all of your pis having the same exact hostname.
-
-Check the "Enable SSH" box and then write a password of your choosing. This will enable us to connect to our Raspberry Pi from a laptop on the local area network, without any display, keyboard, or mouse.
-    1. Advanced SSH Users: Alternatively to choosing a password, you can select the public key authorization option and paste in your public key.
-
-Optionally, configure your wifi network settings, including your WiFi SSID, WiFi password, and WiFi country.
-
-Check "Set locale settings", set your locale, and check "Skip first run wizard". This will let you bypass a prompt for your locale settings when you first boot your raspberry pi.
-
-![image](https://user-images.githubusercontent.com/7269185/157144632-0e0cdc57-0efb-4011-9e6a-2fc02c759159.png)
-
-Now that you've configured your advanced options, press the "Save" button.
-
-### Write the SD Card
-Finally, from the main window, press the "Write" button. Note that this will erase anything already on your microSD card.
-
-Wait for the "Writing" progress bar to complete. A window will pop up letting you know it's safe to remove your microSD card now.
-
-### Remove SD Card
-Remove your microSD card.
-
-### Connecting via WiFi? Extra Note
-If you plan to connect your Pi to the local area network with WiFi rather than Ethernet, you can configure those settings prior to writing your SD card, from the same "Advanced Options" menu. Or alternatively, you can to plug the microSD card back after writing, navigate to the "boot" directory, and create a special file called "wpa_supplicant.conf". You can follow these [instructions for writing and copying the wpa_supplicant.conf file](https://linuxhint.com/rasperberry_pi_wifi_wpa_supplicant/).
diff --git a/docs/model1/simple-ioc/build-run-simple-ioc.md b/docs/model1/simple-ioc/build-run-simple-ioc.md
new file mode 100644
index 0000000..d6992bb
--- /dev/null
+++ b/docs/model1/simple-ioc/build-run-simple-ioc.md
@@ -0,0 +1,187 @@
+# Create and Run a Simple EPICS IOC
+
+This tutorial will guide you through creating your first EPICS Input/Output Controller (IOC) on your Raspberry Pi. An IOC is the core component that hosts process variables and serves data to EPICS clients.
+
+## Step 1: Create IOC Application Directory
+
+First, create a dedicated directory for your IOC application:
+
+```bash
+cd ~
+mkdir myioc
+cd myioc
+```
+
+## Step 2: Generate Base App and IOC Skeleton
+
+Use the EPICS makeBaseApp tool to generate the application structure:
+
+```bash
+/home/debian/Apps/epics/base-7.0.8/bin/linux-arm/makeBaseApp.pl -t example myioc
+```
+
+This creates the basic directory structure and Makefiles needed for an EPICS application.
+
+## Step 3: Compile the Application Source
+
+Navigate to the source directory and compile the application:
+
+```bash
+cd myiocApp/src/
+make
+```
+
+## Step 4: Build the Application & Install Components
+
+Move up one directory level and build the complete application:
+
+```bash
+cd ..
+make
+```
+
+This compiles all components and prepares the IOC for database and boot configuration.
+
+## Step 5: Add the Database File
+
+Create a database file that defines your process variables (PVs):
+
+```bash
+mkdir -p ~/myioc/db  # Create db directory if it doesn't exist
+cd ~/myioc/db
+nano myioc.db
+```
+
+Add the following content to define two test records:
+
+```
+record(ai, "test:example1") {
+  field(DESC, "Test input 1")
+  field(VAL, "42")
+}
+
+record(ai, "test:example2") {
+  field(DESC, "Test input 2")
+  field(VAL, "13")
+}
+```
+
+After saving the database file, rebuild the application:
+
+```bash
+cd ~/myioc/
+make
+```
+
+## Step 6: Generate the IOC Boot Directory
+
+Create the IOC boot configuration:
+
+```bash
+/home/debian/Apps/epics/base-7.0.8/bin/linux-arm/makeBaseApp.pl -i -t example myioc
+```
+
+When prompted for the application name, simply press Enter to use the default (myioc).
+
+## Step 7: Manually Create envPaths File
+
+The envPaths file sets up environment variables for your IOC:
+
+```bash
+cd ~/myioc/iocBoot/myioc
+nano envPaths
+```
+
+Add the following content:
+
+```bash
+epicsEnvSet("TOP", "/home/debian/myioc")
+epicsEnvSet("IOC", "myioc")
+epicsEnvSet("ARCH", "linux-arm")
+```
+
+Make the file readable:
+
+```bash
+chmod +r envPaths
+```
+
+## Step 8: Edit st.cmd
+
+The startup command file (st.cmd) configures and starts your IOC:
+
+```bash
+nano st.cmd
+```
+
+**Note:** There might be prefilled content in `st.cmd`. If needed, remove the existing file and create a new one.
+
+Add the following content:
+
+```bash
+#!../../bin/linux-arm/myioc
+< envPaths
+cd "/home/debian/myioc"
+
+## Register all support components
+dbLoadDatabase("dbd/myioc.dbd", 0, 0)
+myioc_registerRecordDeviceDriver(pdbbase)
+
+## Load record instances
+dbLoadRecords("db/myioc.db", "user=debian")
+
+cd "/home/debian/myioc/iocBoot/myioc"
+iocInit
+```
+
+Make the file executable:
+
+```bash
+chmod +x st.cmd
+```
+
+## Step 9: Run the IOC
+
+Start your IOC:
+
+```bash
+./st.cmd
+```
+
+You should see initialization messages ending with:
+
+```
+iocRun: All initialization complete
+```
+
+Your IOC is now running and serving the process variables you defined.
+
+## Step 10: Test from Separate Terminal
+
+Open a new SSH session to your Pi and test your IOC:
+
+```bash
+caget test:example1
+caget test:example2
+```
+
+**Expected Output:**
+```
+test:example1                          42
+test:example2                          13
+```
+
+## Success!
+
+Congratulations! You have successfully created and run your first EPICS IOC. Your IOC is now:
+- Serving two process variables (`test:example1` and `test:example2`)
+- Accessible from EPICS clients on your network
+- Ready for expansion with additional records and functionality
+
+## Next Steps
+
+With a working IOC confirmed, you're ready to integrate real hardware:
+
+**Next tutorial:** [Flash Arduino SCPI](../arduino-set-up/flash-arduino.md) - Prepare your Arduino device with SCPI communication protocol
+
+This will enable your IOC to communicate with physical hardware devices through serial communication.
\ No newline at end of file
diff --git a/docs/model1/pi-epics-install.md b/docs/model1/simple-ioc/pi-epics-install.md
similarity index 92%
rename from docs/model1/pi-epics-install.md
rename to docs/model1/simple-ioc/pi-epics-install.md
index c27c813..df31033 100644
--- a/docs/model1/pi-epics-install.md
+++ b/docs/model1/simple-ioc/pi-epics-install.md
@@ -116,4 +116,9 @@ The variables aren't yet updated in your system. You have two options to load th
 You can now build local EPICS databases and use commands like "softIoc" and "caget"! Tinker around with these commands for a little while by following the online tutorial ["Test EPICS"](https://docs.epics-controls.org/projects/how-tos/en/latest/getting-started/installation.html#test-epics).
 
 ## What's Next?
-When you're ready to set up a real device that communicates via USB Serial commands, such as the Arduino setups we've created for the Sidekick System, move along to the next step here! The next step will guide you through installing the EPICS *asyn* and *streamDevice* modules!
+
+Now that EPICS v7 is installed, let's test it by creating your first IOC:
+
+**Next tutorial:** [Create and Run a Simple EPICS IOC](../simple-ioc/build-run-simple-ioc.md) - Build and test a basic IOC to verify your EPICS installation
+
+After confirming your IOC works, you'll be ready to integrate hardware devices and build more complex distributed systems.
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index 9fca134..b9a08d9 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -5,22 +5,30 @@ nav:
     - 'sidekick-motivation.md'
     - 'sidekick-analogies.md'
     - Model 1:
-        - 'model1/model1-architecture.md'
         - 'model1/model1-process-variables.md'
-        - Client Demos (Python):
+        - A.) Getting Started:
+            - 'model1/getting-started/1-requirements-and-overview.md'
+            - 'model1/getting-started/2-hardware-ethernet-setup.md'
+            - 'model1/getting-started/3-wifi-configuration.md'
+            - 'model1/getting-started/4-ssh-and-flashing.md'
+        - B.) Running Simple IOC:
+            - Install EPICS v7: 'model1/simple-ioc/pi-epics-install.md'
+            - Build & Run Hello World IOC: 'model1/simple-ioc/build-run-simple-ioc'
+        - C.) Arduino Set-Up:
+            - Flash Arduino with SCPI Firmware: 'model1/arduino-set-up/flash-arduino.md'
+            - Serial Port Communication: 'model1/arduino-set-up/serial-port-communication.md' 
+        - D.) Building Sidekick Model 1: 'model1/model1-architecture.md'
+        - E.) Building Sidekick EPICS IOCs:
+            - Source Code/CAD: 'model1/model1-source-components.md'
+            - Install StreamDevice: 'model1/pi-stream-device-install.md'
+            - Install and Configure systemd-ioc: 'model1/pi-systemd-softioc-setup.md'
+            - 'model1/pi-systemd-softioc-sidekick.md'
+        - F.) Client Demos (Python):
             - 'model1/demos/HelloSidekick.ipynb'
             - 'model1/demos/OpenLoop.ipynb'
             - 'model1/demos/OpenLoopBrightness.ipynb'
             - 'model1/demos/OpenLoopHRR.ipynb'
             - 'model1/demos/ClosedLoopBasics.ipynb'
-        - Building from Scratch:
-            - Source Code/CAD: 'model1/model1-source-components.md'
-            - Flash Your Raspberry Pi: 'model1/pi-flash.md'
-            - First Boot: 'model1/pi-first-boot.md'
-            - Install EPICS v7: 'model1/pi-epics-install.md'
-            - Install StreamDevice: 'model1/pi-stream-device-install.md'
-            - Install and Configure systemd-ioc: 'model1/pi-systemd-softioc-setup.md'
-            - 'model1/pi-systemd-softioc-sidekick.md'
     - Model 3:
         - 'model3/model3-architecture.md'
         - 'model3/model3-process-variables.md'