Raspberry Pi and Web Development: A Practical Guide (Part 2)

26. June 2025

By: ccadm1n

Reading time: 6:29 min

SK

In the previous part, we explored the potential of using Raspberry Pi devices for web development and explained what to focus on when choosing the right model and accessories. This time, we’ll dive into the first steps after purchase — how to safely assemble your Raspberry Pi, get it up and running, and prepare it for your future software experiments.

But don’t expect a one-size-fits-all manual. Raspberry Pi isn’t just about following step-by-step guides — it’s about learning how to think, how to improvise, and how to solve unexpected problems. A bit of frustration is perfectly normal in this process. Every setback or dead end is also an opportunity to learn something new. In this article, we’ll give you an overview of the key areas you’ll likely encounter and share a few tips to help you navigate your Raspberry Pi journey successfully.

Before You Begin: A Few Principles That Will Save You Headaches

Test as you go.
Before you lock your Raspberry Pi into a sleek case and tighten all the screws, make sure everything works as expected. It’s always better to test each component step-by-step rather than troubleshooting later through a fully assembled setup.
Patience is key.
If you hit a snag, don’t get discouraged. Treat confusion as a signal to slow down and learn more about the technology. Every challenge you overcome will sharpen your skills and boost your confidence.
Consider connecting a display and keyboard.
You can set up your Raspberry Pi in headless mode — that is, without a monitor, keyboard, or mouse. But if you’re just getting started, having direct visual feedback and input control can make troubleshooting a lot easier, especially when something doesn’t go as planned.
Take ChatGPT’s answers with a grain of salt.
The strength of language models is that you can ask about very specific situations and often get to a solution quickly. The downside? They’re not infallible. If something feels off or unclear, double-check with other sources. Or at the very least, ask the AI to explain each step so you understand what you’re doing, instead of blindly following instructions.

Hardware Assembly

If your goal is to use your Raspberry Pi primarily as a web server, the setup is usually quite straightforward. Just follow the instructions that come with your accessories — in most cases, a standard PH1 Phillips screwdriver will do the job.

That said, there are some important safety guidelines to keep in mind:

Never remove the microSD card, SSD, or power adapter while the device is running.
Doing so can result in data loss or even permanent damage to the file system.
Watch your grip.
If you need to handle the Raspberry Pi while it’s powered on, always hold it by the outer edges or the corners of the PCB (for example, near the screw holes). Avoid touching chips or other components directly.
Be mindful of static electricity.
Raspberry Pi is a sensitive electronic device, and most Pi power adapters don’t include grounding. A static discharge can damage delicate components. Before touching the device, ground yourself by touching something metal and earthed — like a PC case or metal furniture.
Avoid short circuits.
If you’re planning to use the GPIO pins — for example, to connect sensors, LEDs, or control peripherals — make sure your wiring is correct! A wrong connection can instantly damage your Raspberry Pi.
Don’t use force.
The components and the board itself are fairly delicate. Handle everything gently, and avoid applying unnecessary pressure. At the same time, ensure that all connectors are firmly seated — poor connections (often caused by the device’s compact size and tight spaces) are a common reason things don’t work. A properly seated connection usually gives a subtle “click” to let you know it’s secure.

How to Get and Configure an OS Image

Before booting up your Raspberry Pi for the first time, you’ll need an operating system. Unless you have very specific requirements based on your tooling, Raspberry Pi OS (formerly known as Raspbian, based on Debian) is usually the easiest and most reliable choice — it just works straight out of the box.

Here’s how to get started:

Download and install the Raspberry Pi Imager on your personal computer (available for Windows, macOS, and Linux).
Connect a blank SD card or SSD to your computer using an adapter. Keep in mind that all data on the selected device will be completely overwritten. Be especially careful if you’re using an open M.2 slot on your PC — make sure you’re writing to the right drive!
Open the Raspberry Pi Imager, choose the desired operating system, and customize the configuration to suit your setup (especially important if you’re installing the Pi in headless mode).
In the Advanced Settings, you can:
- Set the device hostname (how it appears on your local network),
- Create a custom username and password,
- Configure Wi-Fi credentials (so the device can connect to the network right after boot, even without an Ethernet cable),
- Enable SSH access for remote control.
For better security, avoid using default values likepi@raspberrypi with the password raspberry. Instead, choose something custom, like tomas_dev@rpiserver with your own secure password. If you plan to use SSH, it’s highly recommended to set up an SSH key protected with a passphrase instead of relying on a simple password.
Finally, click the Write button. Once the process completes, simply remove the card (or SSD) and insert it into your Raspberry Pi — ready to power up!

What Is SSH and How Do I Create an SSH Key?

SSH (Secure Shell) is a secure way to connect to and control a remote device, allowing you to manage your Raspberry Pi safely from your own computer via the terminal.
You can set up SSH login using a simple password, but authentication via an SSH key is more secure — especially if you plan to expose your device to the internet. It also allows you to log in without entering a password each time.
You can generate a key in your terminal using the following command:
```
ssh-keygen -t ed25519 -C "your_name@computer"
```
The argument -C “your_name@computer” is an optional comment used as a personal note to help you identify the key more easily.
If you use multiple SSH keys, you can specify a custom name or path during generation at the prompt “Enter file in which to save the key” — for example: id_ed25519_rpiserver.
Setting a passphrase is optional and serves as an extra layer of protection — without it, anyone who gets access to your key could misuse it.
After the key is generated, two files will be created:
- ~/.ssh/id_ed25519 – the private key, which must remain safe on your computer; never share it.
- ~/.ssh/id_ed25519.pub – the public key, which you can share; Raspberry Pi will use it to identify you.
You can view the contents of the public key with the command:

cat ~/.ssh/id_ed25519.pub

If you need to revoke access later, simply remove the corresponding public key from the ~/.ssh/authorized_keys file on your Raspberry Pi.

How to Control a Raspberry Pi Device

If you plan to use your Raspberry Pi as a personal computer, local peripherals (monitor, keyboard, and mouse) are a given. That direct interaction can also be helpful during your initial setup or when troubleshooting more complex issues. This way, you can see exactly what’s happening on the device and react immediately. However, if you’re planning to run your Raspberry Pi as a web server, you’ll mostly be interested in remote SSH access — which has become the standard today.

So, if you want to control your Raspberry Pi from your main computer (and SSH access is already enabled on the device), you can do so using the command: ssh username@hostname, where usernameis the user account name on the Raspberry Pi, and hostname is the name of the device on your local network. If you chose password protection, you’ll be prompted to enter it. If you’re using SSH key authentication, the login behavior will depend on whether the key is protected with a passphrase or not. If your key has a non-standard name or is stored in a custom location, you’ll also need to specify the path to it, like this:

ssh -i "C:\Users\<User Name>\.ssh\id_ed25519_rpiserver" tomas_dev@rpiserver

How to Avoid Repeatedly Entering the Password and Key Path?

If you want to avoid entering the key path or passphrase every time you log in, you can add your key to the SSH agent on your computer. Below is an example of how to do this using Windows PowerShell (you’ll need to run the terminal in Administrator mode):

				
					Set-Service -Name ssh-agent -StartupType Automatic # Sets the 'ssh-agent' service to start automatically with the system
Start-Service ssh-agent # Starts the 'ssh-agent' service immediately
Get-Service ssh-agent # Verifies that the agent is running (Status: Running)

# Add your key to the agent (may require passphrase if set):
ssh-add "C:\Users\<User Name>\.ssh\id_ed25519_rpiserver"

# Now you can connect like this, without re-entering the path or passphrase (the stored key will be used automatically):
ssh pi@rpiserver

If you’re having trouble connecting and want to check whether the device is even on the network, try the command:ping <hostname>. Once you’re successfully connected, you’ll be able to control the device just like you would through a terminal directly on it. The first login is the perfect time to update the software on your device.

				
					sudo apt update # Downloads the latest list of available packages
sudo apt upgrade # Installs all available updates
sudo reboot # Restarts the device to apply changes fully

Basics of Working with the Linux Terminal

If you haven’t had any hands-on experience with the Linux terminal yet, now is the perfect time to get familiar with at least the basics. The terminal allows you to control your device quickly and efficiently using text commands. Here’s a quick overview of the most commonly used commands to help you get started:

				
					ls # Lists the contents of the current directory (ls -a shows hidden files as well)
cd <directory> # Changes the current directory (e.g., cd /home/pi)
   # Use `..` to go up one level
   # Use `~` to return to the home directory
pwd # Prints the current path / working directory
mkdir <directory> # Creates a new directory
touch <file> # Creates a new file
rm <file> # Deletes a file (rm -r <directory> deletes a directory and its contents)
cp <source> <target> # Copies a file or directory
mv <source> <target> # Moves (or renames) a file / directory
nano <directory> # Simple text editor, great for quick config edits directly in the terminal (exit with Ctrl + X)
cat <file> # Displays the content of a file in the terminal
sudo <command> # Runs a command with administrative privileges (use with caution)
sudo apt update # Updates the list of available packages
sudo apt upgrade # Updates installed packages
sudo apt install <package_name> # Installs a package
exit # Ends the current SSH or terminal session
sudo reboot # Reboots the device
sudo shutdown -h now # Shuts down the device immediately

The Linux terminal is case-sensitive, so be mindful of letter casing when typing commands or filenames.
You can speed up your workflow by using the up and down arrow keys to scroll through your command history, and the TAB key to auto-complete commands and file names.

Use the && symbol to run multiple commands in sequence, and the | (pipe) symbol to pass the output of one command as input to another.

If you’re unsure how to use a specific command, add the –help flag (e.g., ls –help), or use the man <command> (e.g., man ls) for detailed documentation.

For a comprehensive list of commands, check out the Linux Command Library, and if you’re looking for a hands-on guide to Linux concepts, the Linux Journey portal is a great place to start.

And Now — Let’s Start Building!

Your Raspberry Pi is finally up and running, the terminal is no longer your enemy, SSH has lost its mystery, and maybe you’ve even mastered the right way to handle the device without damaging the chips. At this point, you’re ready to turn your Raspberry Pi into a full-fledged development station: install your preferred programming languages and tools, set up Git, and jump into local development. You can code directly on the device, or use your personal computer’s editor — thanks to SSH access, which is either built into most modern editors or available via plugins.

Or, if you’re ready to level up, an even better option might be to treat your Raspberry Pi as a clean runtime server. In that setup, you handle development and builds on your powerful workstation, then simply deploy the finished code or a Docker container to your Pi. How to do that — and what to consider before launching an app into production — will be the focus of the third and final part of our series. Our journey is just getting started. Good luck!