DEV Community: Vincent Tommi

Fixing PostgreSQL Permission Errors in Laravel PHPUnit Tests

Vincent Tommi — Sun, 18 Oct 2026 05:52:00 +0000

Introduction

When writing automated tests in Laravel, configuring the testing environment correctly is just as important as writing the tests themselves.

While setting up a feature test for a menu-category API in my Laravel POS project, I encountered a PostgreSQL permission error that prevented Laravel from creating the migrations table.

The error was:

SQLSTATE[42501]: Insufficient privilege: 7
ERROR: permission denied for schema public

SQL: create table "migrations" (...)

In this article, I'll explain why this error occurs, how to configure a dedicated PostgreSQL test database, and how to use Laravel's RefreshDatabase trait to prepare the database for automated tests.

1. Understanding the Problem

My initial goal was to test whether the menu_categories table existed.

I created a feature test using Laravel's Artisan command:

php artisan make:test MenuCategoryApiTest

However, when I ran the test, Laravel failed to create its migration tracking table.

The root cause was PostgreSQL permissions.

Even though my samu_user role had access to the samu_test database, the database was owned by postgres. The application user did not have the necessary permissions to create tables in the public schema.

Why does this happen?

PostgreSQL manages permissions at different levels:

Database privileges: Control access to the database.
Schema privileges: Control access to objects and operations within a schema.
Table privileges: Control operations such as reading, inserting, updating, and deleting rows.

Granting access to a database does not automatically guarantee permission to create tables inside its schemas.

2. Creating a Dedicated Test Database

Automated tests can create, modify, or roll back database structures. Therefore, I used a separate test database rather than running tests against my development database.

First, I listed the available PostgreSQL databases:

sudo -u postgres psql -l

My database list included:

Name       | Owner
-----------+----------
postgres   | postgres
samu       | samu_user
samu_test  | postgres

The samu_test database existed, but its owner was postgres.

To avoid accidentally modifying the main samu database, I kept samu_test dedicated to automated testing.

3. Fixing PostgreSQL Permissions

I changed the owner of the test database to samu_user:

sudo -u postgres psql -c \
"ALTER DATABASE samu_test OWNER TO samu_user;"

Next, I changed ownership of the public schema:

sudo -u postgres psql -d samu_test -c \
"ALTER SCHEMA public OWNER TO samu_user;"

These commands ensure that the application user can create the tables required by Laravel's migrations in the test database.

I verified the schema permissions with:

sudo -u postgres psql -d samu_test -c "\dn+ public"

Important: These commands should be run only when you intend to grant the application role ownership of the dedicated test database and schema.

4. Configuring PHPUnit for PostgreSQL

Laravel reads its testing environment from PHPUnit configuration and, when applicable, a .env.testing file.

I configured the database-related environment variables in phpunit.xml:

<env name="APP_ENV" value="testing"/>
<env name="DB_CONNECTION" value="pgsql"/>
<env name="DB_HOST" value="127.0.0.1"/>
<env name="DB_PORT" value="5432"/>
<env name="DB_DATABASE" value="samu_test"/>
<env name="DB_USERNAME" value="samu_user"/>

If PostgreSQL requires password authentication, the appropriate password must also be configured securely.

The important settings are:

Setting	Purpose
`APP_ENV`	Activates the testing environment
`DB_CONNECTION`	Selects PostgreSQL
`DB_HOST`	Specifies the database server
`DB_PORT`	Specifies the PostgreSQL port
`DB_DATABASE`	Selects the test database
`DB_USERNAME`	Specifies the PostgreSQL role

Make sure the database name is consistent across your configuration files. In my case, the intended test database was samu_test.

Also check .env.testing for conflicting values, since Laravel may load that file when running tests.

5. Using Laravel's RefreshDatabase Trait

Laravel provides the RefreshDatabase trait to prepare the database for tests.

I added it to tests/Feature/MenuCategoryApiTest.php:

<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class MenuCategoryApiTest extends TestCase
{
    use RefreshDatabase;

    public function test_menu_categories_table_exists(): void
    {
        $this->assertDatabaseHas('migrations', [
            'migration' =>
                '2026_09_18_034452_create_menu_categories_table',
        ]);
    }
}

This example checks whether a particular migration is recorded in Laravel's migration history. It assumes that the migration has run and that its filename matches the value shown.

RefreshDatabase prepares the database using Laravel's migration and transaction mechanisms as appropriate.

It is useful when tests need a predictable database state, but the test database must be configured correctly before using it.

6. Running the Test

After updating the configuration and permissions, I ran:

php artisan config:clear
php artisan test --filter=MenuCategoryApiTest

Initially, the test failed because PostgreSQL could not create the migrations table.

After correcting the database and schema ownership, the test passed:

PASS  Tests\Feature\MenuCategoryApiTest
✓ menu categories table exists

Tests: 1 passed
Time: 3.69s

This confirmed that Laravel could connect to the configured PostgreSQL test database and that the assertion succeeded.

It did not yet prove that all menu-category API operations worked correctly. Those require additional feature tests.

7. Understanding PHP Deprecation Warnings

Even after the test passed, PHP displayed warnings from the nunomaduro/collision package:

PHP Deprecated:
Implicitly marking parameter $throwable as nullable
is deprecated

These warnings were separate from the PostgreSQL permissions problem.

They indicate that the installed package uses parameter declarations that newer PHP versions deprecate.

To investigate compatibility, I checked the installed versions:

php -v
composer show nunomaduro/collision
composer show laravel/framework
composer show phpunit/phpunit

Before upgrading dependencies, check which Collision version is compatible with the installed Laravel and PHPUnit versions.

A passing test can still produce deprecation warnings, so it is worth addressing these separately.

8. What Should Be Tested Next?

Checking whether a database table exists is a useful first step, but a complete API test suite should cover application behavior.

For a menu-category API, I would add the following tests:

Test	Expected behavior
List categories	Returns the expected response
Create category	Saves valid data
Validate input	Rejects invalid data
Show category	Returns the requested category
Update category	Persists changes
Delete category	Removes the record
Prevent duplicates	Enforces the intended uniqueness rules
Validate relationships	Handles warehouse and kitchen-section references correctly

Migration tests can also verify the expected columns, foreign keys, and constraints.

Once the feature tests are in place, run the complete suite:

php artisan test

Conclusion

This troubleshooting experience reinforced an important lesson: automated testing depends on both application code and a correctly configured database environment.

When using Laravel with PostgreSQL, remember to:

Create a dedicated test database.
Configure PHPUnit to use the correct database and user.
Grant the necessary database and schema permissions.
Use RefreshDatabase when appropriate.
Separate database failures from PHP deprecation warnings.
Test API behavior, not just the existence of database tables.

Fixing these fundamentals makes Laravel applications easier to test, debug, and maintain.

Understanding Key Business Stakeholders Through Software Development

Vincent Tommi — Sat, 17 Oct 2026 07:28:00 +0000

Understanding Key Business Stakeholders Through Software Development

Connecting Business Studies with Real-World Technology

When building software, it's easy to focus entirely on writing code, designing databases, creating APIs, and fixing bugs. However, successful software development requires more than technical skills.

Every business has people and organizations that influence its operations or are affected by its decisions. These are known as stakeholders.

Whether you're developing a restaurant management system, an e-commerce platform, a property management application, or a financial system, understanding stakeholders helps you build software that solves real problems.

In this article, we'll explore the key stakeholders in a business and how they relate to software development.

What Are Business Stakeholders?

Business stakeholders are individuals, groups, or organizations that have an interest in a business because they can affect it or be affected by its activities.

For example, when developing an online shopping platform, stakeholders may include business owners, customers, employees, suppliers, payment providers, and competing businesses.

Each stakeholder has different needs and expectations. A developer must understand these needs before designing and implementing a solution.

Let's examine five important stakeholders.

1. The Company: The Business Organization

A company is an organization established to carry out business activities. It brings together people, equipment, buildings, technology, and other resources needed to provide goods or services.

Companies range from individuals operating small businesses to large corporations operating in multiple countries.

How does this relate to software development?

Imagine a restaurant that wants to replace manual sales records with a Point of Sale (POS) system.

The restaurant is the business organization that will use the software to manage its operations.

The system might include:

Sales and order management.
Inventory tracking.
Menu and product management.
Employee accounts and permissions.
Financial reports.
Customer records.

The software should support the company's actual business processes rather than introduce unnecessary complexity.

Before writing code, developers should understand how the company operates, what problems it faces, and what it expects the system to achieve.

Key takeaway: The company provides the business environment in which the software operates. Understanding its processes helps developers build practical solutions.

2. Owners: The People Who Invest in the Business

Owners are the individuals or organizations that own a business and have a financial interest in its success.

They may provide the initial capital needed to start the business. Entrepreneurs often develop business ideas and take risks, but they may invite other investors to contribute funding.

In companies, shareholders become partial owners by purchasing shares.

Owners generally want the business to remain sustainable, grow, manage risks, and generate satisfactory returns.

How does this relate to software development?

Suppose a business owner invests in developing an e-commerce platform.

The owner may want the platform to:

Increase sales.
Reduce operational costs.
Reach more customers.
Protect business information.
Provide useful sales reports.

As a developer, you need to understand these business goals because they influence project requirements and priorities.

For example, if the owner's main objective is to increase sales, improving the checkout process may be more valuable than adding a complicated feature that customers rarely use.

However, technical decisions should balance business goals with security, reliability, accessibility, and long-term maintenance.

Key takeaway: Owners provide resources and direction, while developers help turn business goals into working software.

3. Customers: The People Who Buy or Use Products and Services

Customers are the people or organizations that purchase a business's goods or services. A group of customers served by a business is known as its market.

Businesses attract customers by offering quality products, useful services, reasonable prices, and a positive customer experience.

Customers can also be classified as internal or external.

External customers

External customers are people or organizations outside the business who purchase or use its products and services.

Example: A customer ordering food through a restaurant's mobile application.

Internal customers

Internal customers are employees or departments within an organization that depend on services, information, or outputs provided by other employees or departments.

Example: A restaurant manager using sales reports generated by the cashier's POS system.

The concept of internal customers reminds businesses that employees also need effective tools, information, and support to serve external customers well.

How does this relate to software development?

When developing an application, understanding customer needs is essential.

For example, customers using an online shopping platform may expect:

Simple registration and login.
Fast page loading.
Secure payments.
Accurate product information.
Order tracking.
Helpful customer support.

If the application is difficult to use or unreliable, customers may abandon it and choose a competitor.

Developers can gather customer requirements through interviews, surveys, feedback, usability testing, and analysis of user behavior.

Key takeaway: Customer needs should guide software features, usability, and quality.

4. Collaborators: External Partners Who Help the Business Operate

Collaborators are individuals or organizations that work with a business but are not part of its internal organization.

They provide products, services, resources, expertise, or infrastructure that help the business operate effectively.

Examples include:

Suppliers.
Banks and financial institutions.
Creditors.
Accounting firms.
Retailers and distributors.
Recruitment agencies.
Technology service providers.

Collaborators may also be described as business partners, alliances, or members of a business network.

How does this relate to software development?

Modern applications rarely operate entirely on their own. They often integrate with external services.

Consider an e-commerce platform that relies on:

A payment gateway to process transactions.
A bank or financial service to support payments.
A delivery company to transport orders.
An email service to send order confirmations.
A cloud provider to host the application.

These organizations are collaborators because they help the business deliver its services.

From a developer's perspective, collaboration often involves APIs, authentication credentials, data exchange, error handling, and monitoring.

For example, if a payment gateway becomes unavailable, the application should handle the failure gracefully instead of incorrectly marking an order as paid.

Developers should also consider data privacy, service agreements, integration costs, and dependency risks.

Key takeaway: Collaborators extend a business's capabilities, and software integrations help different organizations work together.

5. Competitors: Businesses Offering Similar Products or Services

Competitors are businesses that compete for the same customers or market opportunities.

They may offer similar products, alternative solutions, or services that satisfy the same customer needs.

Businesses study competitors to understand market trends, identify opportunities, improve their offerings, and develop a competitive advantage.

A competitive advantage is something that allows a business to perform better than its rivals in ways that matter to customers.

How does this relate to software development?

Imagine you're building a property management application for landlords and tenants.

Other applications may already offer similar services. To compete effectively, your application needs to provide meaningful value.

You might differentiate it through:

Easier property registration.
Reliable rent payment tracking.
Faster maintenance request handling.
Better communication between landlords and tenants.
Clear financial reports.
Strong security and data protection.

Competitor analysis can help identify missing features and weaknesses in existing solutions.

However, copying competitors is not always the best strategy. A better approach is to understand customer problems and build a solution that addresses them effectively.

Key takeaway: Competitors encourage businesses to innovate, improve quality, and offer better value.

Connecting Stakeholders to a Software Project

Let's bring these concepts together using a restaurant management system as an example.

Stakeholder	Main interest	Example in the system
Company	Efficient operations	Managing orders and inventory
Owners	Profitability and growth	Viewing revenue and expenses
External customers	Convenient service	Placing and tracking orders
Internal customers	Efficient work	Cashiers and kitchen staff managing orders
Collaborators	Successful service delivery	Payment gateways and suppliers
Competitors	Winning the same market	Other restaurant POS providers

Each stakeholder has different expectations, so developers must identify and prioritize requirements carefully.

For example, restaurant owners may prioritize sales reports, kitchen staff may need immediate order notifications, and customers may care most about ordering speed.

A successful system must account for these different needs without compromising security or reliability.

Why Stakeholder Analysis Matters in Software Engineering

Stakeholder analysis is the process of identifying stakeholders, understanding their interests, and assessing how they influence a project.

It is important because it helps developers:

Gather accurate requirements: Understand what different users actually need.
Set priorities: Focus on features that provide the greatest value.
Reduce misunderstandings: Clarify expectations before implementation.
Manage conflicts: Balance competing requirements and limited resources.
Improve adoption: Build systems that fit real working practices.
Manage risks: Identify dependencies and potential problems early.

For example, an owner might request detailed access to all system data, while an employee's role should restrict access to sensitive financial or personal information. Stakeholder analysis helps reveal these requirements so the developer can implement appropriate permissions.

Conclusion

Business stakeholders are essential to understanding how an organization operates and what it needs to succeed.

The company provides the organizational environment, owners invest resources, customers create demand, collaborators support operations, and competitors influence market decisions.

As software developers, we should understand these relationships before building applications. The best software solutions do more than execute code correctly: they support business objectives, meet user needs, and create value for the people and organizations involved.

Remember: Good software development starts with understanding people and their problems, not just choosing a programming language or framework.

Discussion

If you were building a restaurant management system, which stakeholder would you prioritize when gathering requirements: the business owner, the employees, or the customers? How would you balance their different needs?

Understanding Business Objectives Through Software Development

Vincent Tommi — Sat, 17 Oct 2026 00:00:00 +0000

Learning Business by Connecting Theory with Technology

Business studies and software development may seem like two different fields, but they are closely connected. Every software application, whether it's a banking system, an e-commerce platform, or a restaurant management system, is built to solve a problem and achieve specific business objectives.

As a software developer learning business concepts, I find it helpful to connect theoretical ideas with real-world software projects. In this article, we'll explore five major business objectives and see how they apply to software development.

1. Profitability: Building Software That Makes Money

Profitability is one of the primary objectives of many businesses. It involves generating more revenue than the business spends on expenses.

In simple terms:

Profit = Revenue − Expenses

For example, imagine you're developing a restaurant management system that helps restaurants manage orders, inventory, payments, and sales.

You could earn revenue by charging restaurants a monthly subscription fee. However, you must also consider expenses such as hosting, domain registration, development time, maintenance, and customer support.

If your software generates KSh 100,000 in monthly revenue and costs KSh 60,000 to operate, the business makes KSh 40,000 in profit.

From a software engineering perspective, profitability also encourages developers to build efficient systems, reduce unnecessary infrastructure costs, and prioritize features that deliver real value to customers.

Businesses may aim to maximize profit or earn a satisfactory level of profit, depending on their goals.

2. Survival: Keeping the Business Running

Survival means ensuring that a business continues operating, especially during challenging economic conditions.

Consider a startup that develops a property management application for landlords and tenants.

Initially, the company may have only a few paying customers. If its operating costs are too high and revenue is too low, it may struggle to survive.

The development team might respond by:

Choosing affordable cloud hosting.
Fixing critical bugs before building unnecessary features.
Automating repetitive business processes.
Listening to customers and improving the product.
Prioritizing features that customers are willing to pay for.

This demonstrates why software developers should understand the business context behind their technical decisions.

A technically advanced application is not necessarily a successful business if the company cannot afford to maintain it.

The lesson: Build software that solves real problems while keeping its operating costs manageable.

3. Prestige: Building a Strong Reputation

Prestige refers to the reputation, recognition, and respect a business earns from customers and society.

In software development, reputation is strongly influenced by the quality and reliability of the products we build.

For example, customers are more likely to trust an e-commerce platform that offers:

A clean and user-friendly interface.
Secure payment processing.
Fast response times.
Reliable services with minimal downtime.
Good customer support.

As developers, we contribute to a company's reputation through clean code, effective testing, secure authentication, good documentation, and reliable APIs.

Imagine two applications that offer the same service. One frequently crashes and exposes customer data to risk, while the other is secure, responsive, and easy to use.

Even if both applications have similar features, customers are more likely to trust the reliable one.

Prestige can also come from adopting modern technology, treating employees fairly, producing high-quality products, and protecting the environment.

The lesson: Software quality is not only a technical concern; it can also influence customer trust and business reputation.

4. Growth: Scaling a Business Through Technology

Growth involves expanding business operations, increasing sales, attracting more customers, and entering new markets.

Software can make this expansion easier.

Consider a restaurant that initially manages orders using paper receipts. As the business grows, it may introduce a point-of-sale (POS) system to manage sales, inventory, payments, and kitchen orders.

Later, the restaurant may expand to several branches. A centralized system could help management monitor sales and inventory across all locations.

Developers can support business growth by designing systems that are maintainable, secure, and capable of handling increased demand.

Important concepts include:

Scalability: The ability of a system to handle increasing workloads.
Maintainability: The ease of modifying and improving software.
Automation: Using software to reduce repetitive manual work.
Integration: Connecting different systems so they can exchange information.
Economies of scale: Reducing the average cost per unit as the scale of operations increases.

For example, a well-designed application may serve 100 customers initially and later support 10,000 customers with appropriate infrastructure improvements.

However, growth does not happen automatically because software is scalable. The business must also attract customers, generate revenue, and manage its operations effectively.

The lesson: Good software architecture can support business expansion, but sustainable growth also requires a viable business strategy.

5. Social Responsibility: Building Software That Benefits Society

Social responsibility means that a business considers its impact on society and the environment, rather than focusing only on profit.

Software developers contribute to social responsibility through the systems they design and the decisions they make.

For example, a food donation platform could connect restaurants with surplus food to charities and people who need it.

Such a platform could include:

Restaurant registration and food listings.
Donation requests and collection scheduling.
Notifications for available food.
Tracking of completed donations.
Reports showing the amount of food redistributed.

The business could operate as a nonprofit organization or use a sustainable revenue model to support its operations.

Other examples of socially responsible software include accessible educational platforms, healthcare information systems, digital financial services, and applications that help communities access essential services.

Developers should also consider data privacy, accessibility, cybersecurity, and the potential harm their applications could cause.

The lesson: Technology can create economic value while addressing important social challenges.

Connecting Business Objectives to Software Engineering

The following table summarizes how the five business objectives relate to software development.

Business objective	Software development application	Example
Profitability	Build cost-effective products that generate revenue	Subscription-based SaaS
Survival	Control operating costs and retain customers	Optimizing cloud expenses
Prestige	Deliver reliable, secure, high-quality software	A trusted banking application
Growth	Design systems that support expansion	Multi-branch POS software
Social responsibility	Solve social problems ethically	A food donation platform

Why Software Developers Should Understand Business

Understanding business objectives helps developers make better technical decisions.

Before implementing a feature, a developer should consider questions such as:

What business problem does this feature solve?
Who will benefit from it?
Will it increase revenue, reduce costs, improve customer satisfaction, or support growth?
Is it secure, maintainable, and reliable?
Could it negatively affect customers or society?

These questions help bridge the gap between writing code and creating meaningful business value.

For example, a developer may be asked to add a reporting feature to a POS system. Instead of simply generating a report, the developer can investigate what management needs to understand: daily sales, stock shortages, product performance, or employee productivity.

That understanding leads to a solution that is more useful to the business.

Conclusion

Business objectives and software development are closely connected. Profitability helps businesses generate sustainable returns, survival keeps them operating, prestige builds trust, growth supports expansion, and social responsibility ensures that businesses consider their impact on society.

As software developers, we should not focus exclusively on whether our code works. We should also understand why the software is being built, who it serves, and how it contributes to the organization's objectives.

The goal is not simply to write code. It is to use technology to solve problems and create business value.

Discussion

If you're a software developer or a student learning business studies, how do you think understanding business objectives can improve the way we design and build software applications?

Share your thoughts in the comments.

Internet Chat and Web Conferencing: Understanding Online Communication

Vincent Tommi — Fri, 16 Oct 2026 22:10:00 +0000

Introduction

The Internet provides many ways for people to communicate, share information, and collaborate across different locations. Examples include email, newsgroups, mailing lists, Internet chat, and web conferencing.

In this article, we will explore two important Internet communication services: Internet Chat and Web Conferencing. We will explain how they work, their main features, and the differences between them.

1. What Is Internet Chat?

Internet chat is a form of online communication that allows two or more people to exchange messages in real time.

It is an example of synchronous communication, where participants communicate at the same time.

Internet chat allows users from different parts of the world to discuss topics, share ideas, ask questions, and exchange information.

Internet Relay Chat (IRC)

Internet Relay Chat (IRC) is a communication protocol that enables users to communicate through text-based chat channels.

IRC provides different channels, each focusing on a particular topic. Users can join channels that match their interests and participate in discussions with other members.

For example, a programming channel might allow developers to discuss programming languages, troubleshoot errors, and share technical knowledge.

Features of Internet Chat

Real-time communication: Users can exchange messages instantly when connected.
Topic-based discussions: Chat channels can focus on specific subjects.
Global participation: People from different countries can communicate.
Information sharing: Users can exchange ideas, ask questions, and learn from others.

Example of Internet Chat

Imagine students working on an assignment. They join an online chat room to ask questions, discuss course topics, and help each other understand difficult concepts.

Other examples include group chats and online messaging platforms.

2. What Is Web Conferencing?

Web conferencing is the use of Internet-based tools to conduct online meetings, presentations, discussions, and training sessions.

It allows people in different geographical locations to participate in the same meeting without being physically present in one room.

Organizations, educational institutions, and businesses use web conferencing to improve communication and collaboration.

Features of Web Conferencing

Depending on the platform, web conferencing may support:

Audio communication: Participants can speak and listen to one another.
Video conferencing: Participants can see one another through video.
Screen sharing: A presenter can display their computer screen to others.
Online presentations: Speakers can present slides and other materials.
Text chat: Participants can send messages during a meeting.
Remote collaboration: People can discuss projects and work together from different locations.

Example of Web Conferencing

A university lecturer conducts an online class for students who are studying remotely. The lecturer shares presentation slides, explains the lesson, answers questions, and interacts with students through audio, video, and chat.

Other examples include remote job interviews, business meetings, and online training sessions.

3. Differences Between Internet Chat and Web Conferencing

Although both services support online communication, their main purposes differ.

Feature	Internet Chat	Web Conferencing
Main purpose	Real-time conversations	Meetings, presentations, and collaboration
Communication style	Often text-based	Audio, video, text, and screen sharing
Participants	Two or more people	Two or more people
Common use	Discussions and quick questions	Online classes, meetings, and training
Example	IRC chat channels	Virtual meetings and online lectures

Important: These services can overlap. Modern chat platforms may support audio and video calls, while web conferencing tools often include text-chat features.

4. Advantages of Internet Chat and Web Conferencing

Both services offer several benefits:

Global communication: People can communicate regardless of their physical location.
Time savings: Users can communicate without travelling to meet in person.
Learning opportunities: Students can discuss course materials and attend online classes.
Collaboration: Teams can share information and work together remotely.
Lower communication costs: Online communication can reduce travel and meeting expenses.

Conclusion

Internet chat and web conferencing are important Internet services that support real-time communication.

Internet chat is commonly used for exchanging messages and participating in topic-based discussions, while web conferencing is mainly used for online meetings, presentations, training, and collaboration.

Understanding the difference between these services helps students and professionals choose the appropriate communication method for different situations.

Quick Revision Notes

Internet chat: Online communication that allows users to exchange messages in real time.
Synchronous communication: Communication that happens in real time.
IRC: Internet Relay Chat, a protocol used for text-based communication through chat channels.
Web conferencing: Using Internet-based tools to conduct online meetings and presentations.
Examples of web conferencing features: Audio, video, screen sharing, presentations, and text chat.
Main difference: Chat focuses on conversations, while web conferencing focuses on meetings and collaboration.

Revision tip: Remember that Internet chat is commonly associated with real-time messaging, whereas web conferencing is associated with online meetings and presentations.

Introduction to the Internet: Understanding FTP (File Transfer Protocol)

Vincent Tommi — Fri, 16 Oct 2026 11:06:00 +0000

Introduction

The Internet provides several services that allow computers to communicate and share resources. One of these services is File Transfer Protocol (FTP), a standard network protocol designed to transfer files between computers over a TCP/IP network.

FTP has traditionally been used to download software, share documents, distribute datasets, and transfer files between remote systems.

In this article, we will explore what FTP is, how it works, its common commands, and its security limitations.

1. What Is FTP?

File Transfer Protocol (FTP) is a network protocol used to transfer files between a client and a server over a TCP/IP network.

An FTP client connects to an FTP server to perform permitted operations, such as:

Downloading files from a remote server.
Uploading files to a remote server.
Listing files and directories.
Navigating remote directories.
Managing files, where the account has the necessary permissions.

For example, a researcher might download a dataset from a public FTP server, or a system administrator might transfer files to a server they manage.

FTP does not automatically grant unrestricted access to a remote computer. The operations a user can perform depend on the server's configuration and account permissions.

2. How Does FTP Work?

FTP uses a client-server model.

FTP client: The application that initiates the connection and requests file operations.
FTP server: The system that accepts connections and provides file-transfer services.
Network connection: FTP traditionally uses TCP to establish reliable communication.

FTP commonly uses two separate connections:

Control connection: Carries commands and server responses. Traditionally, the server listens on TCP port 21.
Data connection: Carries file contents and directory listings. Its connection details depend on whether active or passive FTP is used.

This separation is an important characteristic of traditional FTP.

Basic FTP workflow

The user starts an FTP client.
The client connects to the FTP server.
The server requests authentication, unless anonymous access or another configured method applies.
The user requests a file listing, download, or upload.
The server performs the permitted operation.
The connection is closed when the session ends.

3. Types of FTP Access

A. Authenticated FTP

Authenticated FTP requires a username and usually a password. The account's permissions determine which files the user can access or modify.

It is commonly associated with controlled file transfers between users and servers.

B. Anonymous FTP

Anonymous FTP allows users to access a server without having an individual account.

A server may accept a conventional username such as:

anonymous

Some servers historically accepted an email address as the password, although this is not a universal requirement.

Anonymous access is generally configured to provide limited permissions, often for downloading publicly available files. It does not necessarily allow uploads or file modification.

Important distinction

Anonymous FTP does not mean that the user has unrestricted access to the server. Access depends on the permissions set by the server administrator.

4. Common FTP Commands

Traditional command-line FTP clients provide commands for interacting with remote files.

Command	Purpose
`ftp hostname`	Attempts to connect to an FTP server.
`ls`	Lists remote files and directories.
`pwd`	Displays the current remote directory.
`cd directory`	Changes the remote directory.
`get filename`	Downloads a file.
`put filename`	Uploads a file, if permitted.
`binary`	Selects binary transfer mode.
`ascii`	Selects ASCII text transfer mode.
`bye`	Ends the FTP session.

Example: Connecting to an FTP server

On systems with a traditional FTP client installed, the syntax is:

ftp ftp.example.com

The hostname ftp.example.com is illustrative. A real connection requires an actual server that supports FTP and permits your connection.

After connecting, the client may prompt for a username and password.

To download a file, you might use:

get report.pdf

To end the session:

bye

Note: Many modern operating systems do not install a command-line FTP client by default. Also, only connect to servers you own or are authorized to access.

5. Active FTP vs. Passive FTP

Traditional FTP supports two common approaches to establishing its data connection.

Active FTP: The client tells the server where to establish the data connection. Firewalls and network address translation (NAT) can make this difficult.
Passive FTP: The client initiates the data connection to a server-provided port. This is often easier to use through client-side firewalls and NAT.

Passive FTP is widely used in modern network environments because it generally works more conveniently with typical client network configurations. However, server firewall rules must still allow the required connections.

6. Advantages of FTP

Historically, FTP has been useful because it supports:

File sharing: Transfers files between connected computers.
Large file transfers: Moves files without relying on email attachments.
Directory browsing: Allows users to list and navigate remote directories when permitted.
Software distribution: Provides a way to distribute software and updates.
Research data access: Enables access to datasets and other public resources.
Batch transfers: Can be automated using scripts and compatible tools.

7. Security Limitations of Traditional FTP

Traditional FTP has an important security weakness: it does not encrypt usernames, passwords, commands, or file contents by default.

On an untrusted network, someone who can monitor the traffic may be able to read sensitive information.

For this reason, traditional FTP is generally unsuitable for transferring confidential information over untrusted networks.

Modern alternatives

FTPS: FTP secured using TLS encryption.
SFTP (SSH File Transfer Protocol): A separate file-transfer protocol that operates over SSH.
HTTPS: Often used to download files securely through a web server.

FTPS and SFTP are not the same protocol. FTPS adds TLS security to FTP, while SFTP uses the SSH protocol and does not require traditional FTP's separate control and data connections.

For secure server administration and file transfers, SFTP is often a practical choice.

Conclusion

FTP is a traditional Internet protocol used to transfer files between clients and servers. It supports downloads, uploads, directory listings, and different access models, including authenticated and anonymous access.

Although FTP remains relevant when studying networking fundamentals and maintaining legacy systems, its lack of encryption makes it unsuitable for many modern security-sensitive tasks. Secure alternatives such as SFTP and FTPS should be considered when protecting credentials and file contents is important.

Quick Revision Notes

FTP: File Transfer Protocol, used to transfer files over a network.
Client: The application that requests file operations.
Server: The system that provides file-transfer services.
TCP port 21: The traditional FTP control port.
Anonymous FTP: Allows limited access without an individual user account.
Active FTP: The server initiates the data connection.
Passive FTP: The client initiates the data connection.
Main security weakness: Traditional FTP does not encrypt traffic by default.
Secure alternatives: SFTP and FTPS.

Remember: FTP transfers files, but SFTP and FTPS provide secure alternatives for protecting file transfers and credentials.

References

Introduction

FTP has traditionally been used to download software, share documents, distribute datasets, and transfer files between remote systems.

In this article, we will explore what FTP is, how it works, its common commands, and its security limitations.

1. What Is FTP?

File Transfer Protocol (FTP) is a network protocol used to transfer files between a client and a server over a TCP/IP network.

An FTP client connects to an FTP server to perform permitted operations, such as:

Downloading files from a remote server.
Uploading files to a remote server.
Listing files and directories.
Navigating remote directories.
Managing files, where the account has the necessary permissions.

For example, a researcher might download a dataset from a public FTP server, or a system administrator might transfer files to a server they manage.

FTP does not automatically grant unrestricted access to a remote computer. The operations a user can perform depend on the server's configuration and account permissions.

2. How Does FTP Work?

FTP uses a client-server model.

FTP client: The application that initiates the connection and requests file operations.
FTP server: The system that accepts connections and provides file-transfer services.
Network connection: FTP traditionally uses TCP to establish reliable communication.

FTP commonly uses two separate connections:

Control connection: Carries commands and server responses. Traditionally, the server listens on TCP port 21.
Data connection: Carries file contents and directory listings. Its connection details depend on whether active or passive FTP is used.

This separation is an important characteristic of traditional FTP.

Basic FTP workflow

The user starts an FTP client.
The client connects to the FTP server.
The server requests authentication, unless anonymous access or another configured method applies.
The user requests a file listing, download, or upload.
The server performs the permitted operation.
The connection is closed when the session ends.

3. Types of FTP Access

A. Authenticated FTP

Authenticated FTP requires a username and usually a password. The account's permissions determine which files the user can access or modify.

It is commonly associated with controlled file transfers between users and servers.

B. Anonymous FTP

Anonymous FTP allows users to access a server without having an individual account.

A server may accept a conventional username such as:

anonymous

Some servers historically accepted an email address as the password, although this is not a universal requirement.

Anonymous access is generally configured to provide limited permissions, often for downloading publicly available files. It does not necessarily allow uploads or file modification.

Important distinction

Anonymous FTP does not mean that the user has unrestricted access to the server. Access depends on the permissions set by the server administrator.

4. Common FTP Commands

Traditional command-line FTP clients provide commands for interacting with remote files.

Command	Purpose
`ftp hostname`	Attempts to connect to an FTP server.
`ls`	Lists remote files and directories.
`pwd`	Displays the current remote directory.
`cd directory`	Changes the remote directory.
`get filename`	Downloads a file.
`put filename`	Uploads a file, if permitted.
`binary`	Selects binary transfer mode.
`ascii`	Selects ASCII text transfer mode.
`bye`	Ends the FTP session.

Example: Connecting to an FTP server

On systems with a traditional FTP client installed, the syntax is:

ftp ftp.example.com

The hostname ftp.example.com is illustrative. A real connection requires an actual server that supports FTP and permits your connection.

After connecting, the client may prompt for a username and password.

To download a file, you might use:

get report.pdf

To end the session:

bye

Note: Many modern operating systems do not install a command-line FTP client by default. Also, only connect to servers you own or are authorized to access.

5. Active FTP vs. Passive FTP

Traditional FTP supports two common approaches to establishing its data connection.

Active FTP: The client tells the server where to establish the data connection. Firewalls and network address translation (NAT) can make this difficult.
Passive FTP: The client initiates the data connection to a server-provided port. This is often easier to use through client-side firewalls and NAT.

6. Advantages of FTP

Historically, FTP has been useful because it supports:

File sharing: Transfers files between connected computers.
Large file transfers: Moves files without relying on email attachments.
Directory browsing: Allows users to list and navigate remote directories when permitted.
Software distribution: Provides a way to distribute software and updates.
Research data access: Enables access to datasets and other public resources.
Batch transfers: Can be automated using scripts and compatible tools.

7. Security Limitations of Traditional FTP

Traditional FTP has an important security weakness: it does not encrypt usernames, passwords, commands, or file contents by default.

On an untrusted network, someone who can monitor the traffic may be able to read sensitive information.

For this reason, traditional FTP is generally unsuitable for transferring confidential information over untrusted networks.

Modern alternatives

FTPS: FTP secured using TLS encryption.
SFTP (SSH File Transfer Protocol): A separate file-transfer protocol that operates over SSH.
HTTPS: Often used to download files securely through a web server.

FTPS and SFTP are not the same protocol. FTPS adds TLS security to FTP, while SFTP uses the SSH protocol and does not require traditional FTP's separate control and data connections.

For secure server administration and file transfers, SFTP is often a practical choice.

Conclusion

Quick Revision Notes

FTP: File Transfer Protocol, used to transfer files over a network.
Client: The application that requests file operations.
Server: The system that provides file-transfer services.
TCP port 21: The traditional FTP control port.
Anonymous FTP: Allows limited access without an individual user account.
Active FTP: The server initiates the data connection.
Passive FTP: The client initiates the data connection.
Main security weakness: Traditional FTP does not encrypt traffic by default.
Secure alternatives: SFTP and FTPS.

Remember: FTP transfers files, but SFTP and FTPS provide secure alternatives for protecting file transfers and credentials.

References

Introduction to Internet Services: Email and the World Wide Web

Vincent Tommi — Fri, 16 Oct 2026 09:00:00 +0000

Introduction

The Internet provides various services that help people communicate, access information, share files, and conduct business worldwide.

Two of the most widely used Internet services are Electronic Mail (Email) and the World Wide Web (WWW). Although they both use the Internet, they serve different purposes.

This article explains how email works, the structure of an email address, the features of email, and how the World Wide Web provides access to online information.

1. Electronic Mail (Email)

Electronic Mail (Email) is an Internet service used to send and receive digital messages over a network.

Email allows a user to communicate with one person or send a message to multiple recipients. Unlike traditional postal mail, email messages can usually be delivered within seconds, depending on network and server availability.

One major advantage of email is that the recipient does not need to be online when the message is sent. The message can remain in the recipient's mailbox until they access it.

Features of Email

One-to-one communication: Send a message to an individual.
One-to-many communication: Send a message to several recipients simultaneously.
Fast delivery: Messages are often delivered within seconds, although delays can occur.
Asynchronous communication: The sender and recipient do not need to be online at the same time.
Global accessibility: Email can be accessed from different locations using an Internet-connected device.
Cost-effectiveness: Email is generally inexpensive compared with traditional postal services.
24/7 availability: Users can send and receive messages at any time, subject to service availability.
File attachments: Users can share documents, images, and other supported files.
Written record: Messages can be stored, searched, and retrieved later.

Components of an Email Address

An email address identifies a mailbox where messages are delivered.

Example:

john@hotmail.com

An email address has two main parts separated by the @ symbol.

Local part: john identifies the mailbox or recipient name within the domain.
Domain part: hotmail.com identifies the domain associated with the email service.

The domain can contain a mail server that receives and processes messages for its users.

Understanding the domain

In john@hotmail.com:

hotmail is the domain label associated with the email service.
.com is a top-level domain (TLD), historically associated with commercial organizations but now used much more broadly.

Other common top-level domains include:

.org — traditionally associated with organizations.
.edu — used for eligible educational institutions, particularly in the United States.
.gov — used for eligible government entities, particularly in the United States.
.ke — Kenya's country-code top-level domain.

Important: These domain extensions do not always reveal the exact type of organization operating a website or email service.

How Does Email Work?

Email relies on several networking protocols:

SMTP (Simple Mail Transfer Protocol): Used to submit and transfer outgoing email.
IMAP (Internet Message Access Protocol): Allows email clients to access and synchronize messages stored on a mail server.
POP3 (Post Office Protocol version 3): Allows an email client to retrieve messages from a mail server.

A simplified email delivery process is:

The sender writes an email using an email application.
The application submits the message to an outgoing mail server using SMTP.
The sending server uses DNS, particularly MX records, to identify the recipient domain's mail server.
The message is transferred to the recipient's mail server.
The recipient accesses the message through a webmail service or email application, often using IMAP or POP3.

Modern email systems commonly use encryption, such as TLS, to protect connections between clients and mail servers.

2. The World Wide Web (WWW)

The World Wide Web (WWW) is a system of interconnected web pages and other resources that users access over the Internet.

It was proposed by Tim Berners-Lee in 1989 and made publicly available in the early 1990s.

The Web makes information accessible through hyperlinks, allowing users to navigate from one page or resource to another.

For example, a student can visit an educational website, follow a link to a research article, and then open another resource without knowing where the underlying servers are physically located.

Key Features of the World Wide Web

Hyperlinks: Connect web pages and resources.
Multimedia: Supports text, images, audio, video, and interactive content.
Global access: Allows users to access publicly available resources from different locations.
Graphical interface: Web browsers provide an accessible way to view and interact with web content.
Information sharing: Supports education, research, entertainment, communication, and business.
Interactive applications: Enables services such as online banking, shopping, learning platforms, and web-based software.

Technologies Used by the Web

The Web depends on several important technologies:

HTML (HyperText Markup Language): Defines the structure and meaning of web page content.
HTTP (Hypertext Transfer Protocol): Defines how web clients and servers exchange resources.
HTTPS (HTTP Secure): Uses TLS to protect HTTP communication.
URL (Uniform Resource Locator): Identifies the location of a resource.
Web browser: Software such as Firefox or Chrome that retrieves and displays web content.
Web server: Software that receives requests and delivers web resources.

How Does the Web Work?

Consider visiting https://example.com.

You enter the URL into a web browser.
DNS helps the browser resolve the domain name to an IP address.
The browser establishes a connection to the server, using HTTPS to protect the communication.
The browser sends an HTTP request.
The server returns a response containing a web page or another resource.
The browser processes the response and displays the content.

This process involves several Internet technologies working together.

3. Difference Between the Internet and the World Wide Web

The Internet and the World Wide Web are related, but they are not the same thing.

Internet	World Wide Web
A global network of interconnected networks.	A service that operates over the Internet.
Uses networking technologies such as IP and TCP.	Uses technologies such as HTTP, URLs, and HTML.
Supports email, the Web, file transfer, and other services.	Provides access to linked web pages and applications.
Includes the underlying network infrastructure.	Uses that infrastructure to exchange web resources.

For example, you can use an email application without opening a web browser. Email is an Internet service, but it is not itself the World Wide Web.

Conclusion

Email and the World Wide Web are important Internet services that support communication and information sharing.

Email enables users to exchange messages and attachments, while the Web provides access to interconnected pages and interactive online applications.

Understanding email addresses, SMTP, IMAP, POP3, DNS, HTTP, and HTTPS provides a useful foundation for studying computer networking and Internet technologies.

Quick Revision Notes

Email: An Internet service for sending and receiving digital messages.
Email address: Identifies a mailbox using a local part and a domain, separated by @.
SMTP: Used for sending and transferring email.
IMAP: Synchronizes access to messages stored on a mail server.
POP3: Retrieves email from a mail server.
WWW: A system of linked web pages and resources accessed over the Internet.
HTML: Structures web content.
HTTP: Defines communication between web clients and servers.
HTTPS: Protects HTTP communication using TLS.
URL: Identifies the location of a web resource.
DNS: Resolves domain names to IP addresses and supports other domain-related functions.

Remember: Email is mainly used for electronic messaging, while the World Wide Web is used to access linked information and web applications.

A Brief History of the Internet: From ARPANET to Global Connectivity

Vincent Tommi — Fri, 16 Oct 2026 07:00:00 +0000

Introduction

The Internet is a global system of interconnected computer networks that communicate using standardized protocols. It enables services such as email, file sharing, online communication, cloud computing, and the World Wide Web.

The Internet did not emerge overnight. It developed through decades of research, networking innovations, and collaboration between universities, governments, and private companies.

This article summarizes the major milestones in the Internet's history and explains how it evolved from a research network into essential global infrastructure.

1. The Origins of the Internet (1950s–1960s)

In 1958, the United States established the Advanced Research Projects Agency (ARPA), later renamed DARPA, to support advanced scientific and technological research.

Researchers began exploring ways for computers to communicate and share resources across networks. An important development was packet switching, a method of dividing data into smaller units called packets for transmission across a network.

In 1969, ARPANET, the precursor to the modern Internet, connected four initial sites:

University of California, Los Angeles (UCLA)
University of California, Santa Barbara (UCSB)
Stanford Research Institute (SRI)
University of Utah

This network demonstrated that geographically separated computers could communicate and share computing resources. Source: Internet Society

2. Network Development and Email (1970s)

During the 1970s, researchers developed networking protocols and applications to improve communication between computers.

Key developments included:

Electronic mail: Email emerged as one of the earliest widely used network applications, with Ray Tomlinson's work in 1971 helping establish network email.
Remote access: Users could connect to remote computers and access their resources.
Network protocols: Researchers worked on standards that would allow different computer networks to communicate.

These developments demonstrated that computer networks could support communication and resource sharing, not merely connect machines.

3. TCP/IP and DNS (1980s)

The 1980s marked a major turning point in Internet development.

TCP/IP

The Transmission Control Protocol/Internet Protocol (TCP/IP) suite became the foundation for communication across interconnected networks.

IP (Internet Protocol): Handles packet addressing and forwarding between networks.
TCP (Transmission Control Protocol): Provides reliable, ordered delivery of data between applications.

On January 1, 1983, ARPANET transitioned from its earlier Network Control Protocol (NCP) to TCP/IP. This milestone helped establish the technical foundation of the modern Internet.

Domain Name System (DNS)

DNS was developed in the 1980s to translate human-readable domain names into IP addresses.

For example, DNS allows a user to enter example.com instead of having to remember a numerical IP address.

NSFNET

In 1986, the United States National Science Foundation developed NSFNET to connect research institutions and support the expansion of academic networking. It became an important part of the Internet's infrastructure.

Together, TCP/IP, DNS, and expanding network infrastructure made it easier to connect increasingly large numbers of computers. Source: Internet Society

4. The World Wide Web and Commercial Growth (1990s)

The 1990s brought major improvements in how people accessed information online.

The World Wide Web

In 1989, Tim Berners-Lee proposed the World Wide Web while working at CERN. The Web introduced a system of interconnected documents accessed through browsers using technologies such as:

HTML (HyperText Markup Language): Structures web pages.
HTTP (Hypertext Transfer Protocol): Enables communication between web clients and servers.
URLs (Uniform Resource Locators): Identify the location of web resources.
Web browsers: Allow users to access and navigate web pages.

The Web became publicly accessible in the early 1990s. The Mosaic browser, released in 1993, helped make browsing more accessible by supporting graphical content.

Important distinction: The Internet is the underlying network infrastructure, while the World Wide Web is a service that operates over it. Email and other Internet services do not depend on the Web itself.

Commercialization

As Internet access expanded, businesses began using it for commercial activities, including:

Online shopping and electronic commerce
Digital advertising and marketing
Online banking
Business-to-business communication
Customer support and information services

In 1995, the NSFNET backbone was retired as commercial network providers increasingly supplied Internet connectivity. This marked an important stage in the transition toward a commercially operated Internet.

5. The Internet Today

The Internet has evolved from a small research network into global infrastructure connecting billions of people and devices.

It supports many modern technologies, including:

Cloud computing and online storage
Social media and instant messaging
Video and voice communication
E-commerce and digital payments
Internet of Things (IoT) devices
Online education and remote work
Artificial intelligence services

Its continued development depends on interoperable protocols, network infrastructure, security practices, and collaboration among technical organizations, service providers, governments, and users.

Key Milestones at a Glance

Year	Milestone
1958	ARPA established
1969	ARPANET connects four initial sites
1971	Ray Tomlinson develops network email
1983	ARPANET transitions to TCP/IP
1984	DNS begins emerging as a practical naming system
1986	NSFNET development begins
1989	Tim Berners-Lee proposes the World Wide Web
1991	The Web becomes publicly accessible
1993	Mosaic browser helps popularize the Web
1995	NSFNET backbone is retired as commercial Internet services expand

Conclusion

The Internet developed through several major stages: early networking research, the creation of ARPANET, the adoption of TCP/IP, the development of DNS, and the growth of the World Wide Web and commercial connectivity.

Its success depends on standardized protocols and interoperability, which allow different devices and networks to communicate regardless of their underlying technologies.

Understanding this history provides a foundation for studying computer networks, Internet protocols, web development, and cybersecurity.

Quick Revision Notes

Internet: A global network of interconnected networks.
ARPANET: An early research network and precursor to the Internet.
Packet switching: Dividing data into packets for transmission across a network.
TCP/IP: The core protocol suite used for Internet communication.
DNS: Maps domain names to IP addresses.
NSFNET: A research and education network that helped expand Internet connectivity.
World Wide Web: A system of interlinked resources accessed over the Internet.
HTML: Structures web page content.
HTTP: Defines communication for transferring Web resources.
Commercialization: The expansion of Internet services for business and public use.

Remember: ARPANET started the journey, TCP/IP enabled interconnected networks, DNS simplified addressing, and the World Wide Web made online information easier to access.

References

Introduction to the Internet: Understanding Telnet for Beginners

Vincent Tommi — Fri, 16 Oct 2026 03:00:00 +0000

Introduction

The internet allows computers around the world to communicate and share resources. One important concept in computer networking is remote access, which allows a user to connect to and interact with a computer located somewhere else.

One of the older tools developed for remote access is Telnet.

In this article, we will explore what Telnet is, how it works, the commands used to connect to remote computers, and why modern systems generally prefer SSH.

What Is Telnet?

Telnet is a network protocol that allows a user to connect to a remote computer and execute commands through a text-based interface.

A remote computer, also called a remote host, is a computer that you access over a network rather than directly using its keyboard and screen.

With Telnet, a user can interact with the remote system as though they were logged in locally, provided they have the necessary access permissions.

Example

Imagine you are in Nairobi and need to access a computer located in another city. Instead of physically travelling to that computer, you could use a remote-access tool to connect over a network.

Telnet was designed to provide this kind of remote terminal access.

Requirements for Using Telnet

To connect to a remote computer using Telnet, you generally need:

Hostname or IP address: Identifies the remote computer.
Valid user account: The remote system must authorize your access.
Network connectivity: Your computer must be able to reach the remote host.
Telnet service: The remote computer must have a Telnet service running and accessible.

Traditional Telnet access is not anonymous by default; you normally need valid credentials and permission to use the remote system.

Common Telnet Commands

Telnet commands specify the remote computer to which you want to connect.

1. Connecting Using a Hostname

The basic syntax is:

telnet hostname

For example:

telnet math.sunysb.edu

This attempts to establish a Telnet connection to the host named math.sunysb.edu.

The connection will only succeed if the hostname resolves, the network permits the connection, and a Telnet service is available.

2. Connecting Using an IP Address

You can also specify the remote computer's IP address:

telnet 192.0.2.10

Here, 192.0.2.10 is an example address reserved for documentation. It is not intended to identify a real public server.

The command attempts to connect to the computer at that address.

3. Connecting to a Specific Port

Telnet can also specify a port number:

telnet hostname port

For example:

telnet example.com 80

This attempts to open a TCP connection to port 80, commonly associated with HTTP.

Note that connecting to a port does not automatically mean you are logging into a computer. Telnet can also be used to test whether a TCP service is reachable, although modern diagnostic tools are often more suitable.

How Does Telnet Work?

The basic process can be summarized in four steps:

The user enters a hostname or IP address.
The computer attempts to establish a network connection with the remote host.
If the service is available, the remote system may request authentication.
Once authorized, the user can interact with the remote terminal.

The connection depends on network availability, service configuration, and access permissions.

Is Telnet Secure?

An important limitation of traditional Telnet is that it does not encrypt the communication by default.

This means that usernames, passwords, and other transmitted information may be exposed to someone monitoring the network.

For this reason, Telnet is generally unsuitable for logging into remote computers over untrusted networks.

Telnet vs. SSH

Feature	Telnet	SSH
Main purpose	Remote terminal access	Secure remote access
Encryption	No encryption by default	Encrypts communication
Credentials	Can be exposed in transit	Protected by encryption
Modern use	Legacy systems and limited diagnostics	Standard choice for remote administration

SSH (Secure Shell) is generally preferred for remote administration because it provides encrypted communication and supports secure authentication.

When Is Telnet Still Useful?

Although Telnet is largely outdated for secure remote login, it can still be encountered in:

Legacy networking environments.
Networking education and demonstrations.
Testing whether a TCP port is reachable.
Older systems that still depend on the protocol.

Only connect to systems you own or are explicitly authorized to access.

Conclusion

Telnet is an older Internet protocol that allows users to connect to remote computers and interact with their command-line interfaces. To use it, you typically specify a hostname or IP address and need permission to access the remote system.

The most important limitation to remember is that traditional Telnet does not encrypt its traffic. For secure remote access, SSH is the preferred modern alternative.

Quick Revision Notes

Telnet: A protocol for accessing a remote computer through a text-based terminal.
Remote host: A computer accessed over a network.
Hostname: The name used to identify a computer on a network.
IP address: A numerical network address identifying a device or interface.
Basic command: telnet hostname
Main disadvantage: Communication is unencrypted by default.
Modern alternative: SSH.

Remember: Telnet provides remote terminal access, while SSH provides remote terminal access with encryption.

Fixing Laravel IDE Helper Errors: Eloquent Relationships, PHP Namespaces, and Model Annotations

Vincent Tommi — Thu, 15 Oct 2026 13:05:00 +0000

When working on a Laravel project, your code can work in some places while your IDE still reports errors about model relationships, return types, or missing methods.

Recently, I encountered this situation while configuring Laravel IDE Helper in a project. The goal was to generate model annotations for better autocomplete, improve code navigation, and help the IDE understand Eloquent relationships.

However, the process revealed several issues involving incorrect imports, class capitalization, relationship return types, and model references.

In this article, we'll walk through the problems, their solutions, and the lessons beginners can learn from them.

1. What is Laravel IDE Helper?

Laravel IDE Helper is a development package that generates PHPDoc annotations to help IDEs such as PhpStorm and VS Code understand Laravel's dynamic features.

Laravel's Eloquent ORM allows us to write code like this:

$warehouse = Warehouse::find(1);

$products = $warehouse->products;

Although this is valid Laravel code, an IDE may not always know which properties, methods, or relationship types are available on the model.

IDE Helper generates documentation that helps the editor recognize those relationships and methods.

Install it in a Laravel project with Composer:

composer require --dev barryvdh/laravel-ide-helper

Generate general helper documentation:

php artisan ide-helper:generate

Generate model annotations:

php artisan ide-helper:models

For more information, see the Laravel IDE Helper repository.

2. Problem One: Incorrect Eloquent Relationship Imports

One of the errors reported during model generation was:

Return value must be of type App\Models\HasMany,
Illuminate\Database\Eloquent\Relations\HasMany returned

A similar error occurred for BelongsTo.

Why did this happen?

PHP uses namespaces to identify classes. When a class name is used without an import or fully qualified namespace, PHP attempts to resolve it according to the current namespace and other applicable rules.

For example, consider this model:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class KitchenSection extends Model
{
    public function warehouse(): BelongsTo
    {
        return $this->belongsTo(Warehouse::class);
    }

    public function menuItems(): HasMany
    {
        return $this->hasMany(MenuItem::class);
    }
}

The BelongsTo type is imported, but HasMany is not.

Because the model is inside the App\Models namespace, PHP may try to resolve HasMany as App\Models\HasMany. Laravel actually returns an instance of Illuminate\Database\Eloquent\Relations\HasMany.

The declared return type and the actual returned object therefore do not match.

The solution

Import both relationship types:

use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;

Now the complete relationship definitions are valid:

public function warehouse(): BelongsTo
{
    return $this->belongsTo(Warehouse::class);
}

public function menuItems(): HasMany
{
    return $this->hasMany(MenuItem::class);
}

Beginner lesson: Whenever you add a return type to an Eloquent relationship, import the correct class from Illuminate\Database\Eloquent\Relations.

Common relationship types include:

Relationship	Return type
One-to-one	`HasOne`
One-to-many	`HasMany`
Inverse one-to-one or one-to-many	`BelongsTo`
Many-to-many	`BelongsToMany`
Polymorphic one-to-one	`MorphOne`
Polymorphic one-to-many	`MorphMany`

3. Problem Two: Incorrect Model Class Names and Capitalization

Another issue involved relationship references such as:

return $this->hasMany(menuItem::class);

The actual model class was named MenuItem.

On a case-sensitive filesystem, capitalization matters. This is especially important when developing on Linux.

Incorrect

return $this->hasMany(menuItem::class);

Correct

return $this->hasMany(MenuItem::class);

The same principle applies to other models:

Warehouse::class
ModifierGroup::class
BillPrint::class
DiningArea::class
IngredientStockMovement::class
MenuItemVariation::class

Always use the exact class name defined by the model.

For example, if your file is:

app/Models/MenuItem.php

The class declaration should normally be:

namespace App\Models;

class MenuItem extends Model
{
    // ...
}

Laravel's PSR-4 autoloading depends on correctly mapping namespaces and class names to files.

Beginner lesson: A model reference can look correct in your editor but fail during runtime or automated tooling because of incorrect capitalization.

4. Problem Three: Fixing the Modifier Relationship

The Modifier model exposed another version of the missing-import problem.

The original relationship looked like this:

public function modifierGroup(): BelongsTo
{
    return $this->belongsTo(modifierGroup::class);
}

Two improvements were necessary:

Import Laravel's BelongsTo relationship type.
Use the correct model class name, ModifierGroup::class.

The corrected relationship was:

use Illuminate\Database\Eloquent\Relations\BelongsTo;

public function modifierGroup(): BelongsTo
{
    return $this->belongsTo(
        ModifierGroup::class,
        'modifier_groups_id'
    );
}

The foreign-key argument is important here.

By convention, Laravel would normally look for modifier_group_id. The explicit argument tells Laravel to use modifier_groups_id instead.

Important: Use the explicit foreign-key name only if that column really exists in your database.

You can inspect your migration files or database schema to verify the column.

5. Understanding Laravel Relationship Conventions

Eloquent relationships describe how database records are connected.

Consider a warehouse that has multiple products:

// Warehouse.php

use Illuminate\Database\Eloquent\Relations\HasMany;

public function products(): HasMany
{
    return $this->hasMany(Product::class);
}

And the inverse relationship:

// Product.php

use Illuminate\Database\Eloquent\Relations\BelongsTo;

public function warehouse(): BelongsTo
{
    return $this->belongsTo(Warehouse::class);
}

Laravel will normally expect a warehouse_id foreign key in the products table.

The relationships allow queries such as:

$warehouse = Warehouse::findOrFail(1);

// Get the related products.
$products = $warehouse->products;

// Get the warehouse associated with a product.
$product = Product::findOrFail(1);
$warehouse = $product->warehouse;

Notice the distinction between $warehouse->products() and $warehouse->products.

products() returns a relationship object, which can be used to build queries.
products accesses the relationship as a property and retrieves the related records, using Eloquent's relationship loading behavior.

Understanding this difference helps when debugging relationship return types and IDE warnings.

6. Generating IDE Helper Model Annotations

After correcting the relationship definitions, I regenerated the helper documentation.

First, rebuild Composer's autoloader:

composer dump-autoload

Then generate the general helper file:

php artisan ide-helper:generate

To generate model annotations and add mixins to the models:

php artisan ide-helper:models -M

The -M option tells IDE Helper to use mixins, helping IDEs recognize the generated model documentation without duplicating every generated method declaration directly in each model.

This generates or updates:

_ide_helper.php
_ide_helper_models.php

The files serve different purposes:

_ide_helper.php provides helper documentation for Laravel's dynamic features.
_ide_helper_models.php contains generated model annotations, including properties, relationships, and query methods.

For example, a generated Warehouse annotation may contain:

@property-read \Illuminate\Database\Eloquent\Collection<int, \App\Models\Product> $products
@property-read \Illuminate\Database\Eloquent\Collection<int, \App\Models\Sale> $sales
@method static \Illuminate\Database\Eloquent\Builder|Warehouse query()

These annotations help the IDE understand model behavior without changing the actual database schema.

The generated documentation is for development assistance; it does not create new Eloquent relationships or replace the real relationship methods.

7. Verifying That the Fix Worked

Generating a file is not enough. We should check whether the errors have actually disappeared.

Step 1: Rebuild the autoloader

composer dump-autoload

Step 2: Regenerate model documentation without writing annotations into model files

php artisan ide-helper:models -N -D 'app/Models/*'

Here:

-N prevents writing the generated annotations directly into model files.
-D specifies the model directory or file pattern to process.

This is useful when you want to test generation without making additional changes to each model.

Step 3: Check Git for whitespace errors

git diff --check

If this command produces no output, Git has not found whitespace errors in the changes it checks.

Step 4: Review the changes

git status --short
git diff --stat

Review the modified models and generated helper files before committing.

A successful verification should include:

No unresolved relationship model errors.
No incorrect relationship return types.
Correct model class names and capitalization.
Generated helper documentation.
No reported whitespace errors.

8. Common Mistakes to Avoid

Mistake 1: Importing the wrong class

Incorrect:

use App\Models\HasMany;

Correct:

use Illuminate\Database\Eloquent\Relations\HasMany;

Mistake 2: Ignoring Linux capitalization rules

Incorrect:

Modifiergroup::class

Correct:

ModifierGroup::class

Use the actual class name, not a guessed variation.

Mistake 3: Assuming IDE Helper creates relationships

IDE Helper documents model behavior for your IDE. You must still define valid Eloquent relationship methods in your models.

Mistake 4: Changing a foreign key without checking the database

Laravel conventions are useful, but existing projects sometimes use custom column names. Confirm the schema before modifying a relationship's foreign-key argument.

Mistake 5: Committing every generated change without reviewing it

The -M command can modify many model files. Always inspect:

git status --short
git diff --check

Make sure temporary backups and unrelated changes are not included in the commit.

9. Final Checklist for Laravel Developers

Before considering an Eloquent relationship complete, verify the following:

The related model exists.
The model class name uses the correct capitalization.
The relationship method uses the correct return type.
The return type imports the correct Laravel relationship class.
Any custom foreign key matches the database schema.
IDE Helper can resolve the relationship.
Git changes have been reviewed before committing.

Conclusion

Debugging Laravel IDE Helper errors taught me an important lesson: understanding PHP namespaces and Eloquent relationship types is just as important as knowing Laravel's syntax.

A missing import, incorrect class capitalization, or mismatched relationship return type can prevent IDE Helper from generating complete model documentation.

The best approach is to verify the model class, check the imports, confirm the database relationship, regenerate the documentation, and inspect the results.

Once these fundamentals become familiar, debugging Eloquent relationships becomes much easier—and your code becomes clearer for both your IDE and other developers.

If you are learning Laravel, try applying these checks to a model in your own project. They are small habits that can prevent hours of debugging later.

Useful resources:

Understanding the PostgreSQL Error: `SQLSTATE[42P01]`

Vincent Tommi — Thu, 15 Oct 2026 11:15:00 +0000

When I ran php artisan migrate:fresh, Laravel failed while creating the menu_categories table.

The error was:

SQLSTATE[42P01]: Undefined table:
ERROR: relation "kitchen_sections" does not exist

What does this error mean?

PostgreSQL uses the word relation to refer to database objects such as tables. In this case, PostgreSQL could not find the kitchen_sections table that my migration referenced.

My menu_categories migration contained:

$table->foreignId('kitchen_section_id')
    ->nullable()
    ->constrained('kitchen_sections')
    ->nullOnDelete();

This code tells Laravel to:

Create a kitchen_section_id foreign-key column.
Reference the id column in the kitchen_sections table.
Allow the foreign key to be NULL.
Set kitchen_section_id to NULL if its referenced kitchen section is deleted.

The relationship itself was valid. The problem was that Laravel attempted to create it before the referenced table existed.

Why did Laravel run the migration in the wrong order?

My migration files were initially named:

2026_09_18_034452_create_menu_categories_table.php
2026_09_22_040308_create_kitchen_sections_table.php

Laravel executes migrations in timestamp order. Since the menu_categories migration had an earlier timestamp, it ran first.

However, menu_categories depended on kitchen_sections, creating a dependency conflict.

How I fixed it

I renamed the kitchen-sections migration so that it would run before the menu-categories migration:

2026_09_18_030000_create_kitchen_sections_table.php
2026_09_18_034452_create_menu_categories_table.php

I also removed an empty, unused migration file that was named recreate_menu_categories_table.

After correcting the migration order, I ran:

php artisan migrate:fresh

The migrations completed successfully.

The main lesson

A foreign key requires its referenced table and column to exist before the constraint can be created. In Laravel, migration timestamps determine the execution order, so dependent tables must be created first.

When troubleshooting SQLSTATE[42P01], check whether the referenced table exists, whether its migration has run, and whether the migration files are ordered correctly.

Refactoring a Laravel API Controller to Reuse AppBaseController Response Helpers

Vincent Tommi — Thu, 15 Oct 2026 06:00:00 +0000

Refactoring a Laravel API Controller to Reuse AppBaseController Response Helpers

When building APIs in Laravel, it's easy to create a controller that works correctly but doesn't follow the response conventions already established in a project.

I recently worked on a MenuCategoryController that handled CRUD operations, pagination, validation, and deletion checks. However, it returned custom JSON responses instead of following the existing AppBaseController pattern used by other controllers in the application.

In this article, I'll explain how to refactor a Laravel API controller to reuse shared response helpers while preserving resource-based responses and proper HTTP status codes.

The Problem: Inconsistent API Responses

My original controller extended Laravel's default Controller:

use App\Http\Controllers\Controller;

class MenuCategoryController extends Controller
{
    // CRUD methods...
}

Some methods returned manually constructed JSON responses:

return response()->json([
    'success' => true,
    'message' => 'Menu Category created successfully.',
    'data' => new MenuCategoryResource($category),
], 201);

Although this works, manually constructing response bodies in multiple controllers can introduce inconsistencies.

For example, one controller might return a success field, while another uses a shared response utility. Over time, this makes the API harder to maintain and its responses less predictable for frontend developers.

The project already had an AppBaseController with reusable response methods, so the better approach was to reuse the existing architecture.

Step 1: Understand the Existing AppBaseController

The existing base controller provides three response helpers:

class AppBaseController extends Controller
{
    public function sendResponse($result, $message): JsonResponse
    {
        return Response::json(
            ResponseUtil::makeResponse($message, $result)
        );
    }

    public function sendError($error, $code = 422): JsonResponse
    {
        return Response::json(
            ResponseUtil::makeError($error),
            $code
        );
    }

    public function sendSuccess($message): JsonResponse
    {
        return Response::json([
            'success' => true,
            'message' => $message,
        ], 200);
    }
}

Each method serves a different purpose:

sendResponse() returns a successful response using the project's ResponseUtil.
sendError() returns an error response with a configurable HTTP status code.
sendSuccess() returns a simple success message.

These helpers establish shared response conventions and reduce duplicated response-handling code.

Important: sendResponse() and sendSuccess() do not return identical JSON structures. Always inspect ResponseUtil::makeResponse() and ResponseUtil::makeError() before assuming their exact output format.

Step 2: Extend AppBaseController

The first change is to replace the default controller import:

use App\Http\Controllers\Controller;

with:

use App\Http\Controllers\AppBaseController;

Then update the class declaration:

class MenuCategoryController extends AppBaseController
{
    // CRUD methods...
}

The controller can now access the shared response helpers without redefining them.

This is a simple example of code reuse and inheritance in PHP: common behavior belongs in a shared parent class, while the child controller focuses on its resource-specific business logic.

Step 3: Implement the CRUD Operations

Below is the refactored controller.

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\AppBaseController;
use App\Http\Requests\StoreMenuCategoryRequest;
use App\Http\Requests\UpdateMenuCategoryRequest;
use App\Http\Resources\MenuCategoryResource;
use App\Models\MenuCategory;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Resources\Json\AnonymousResourceCollection;

class MenuCategoryController extends AppBaseController
{
    /**
     * Display a paginated listing of menu categories.
     */
    public function index(): AnonymousResourceCollection
    {
        $categories = MenuCategory::query()
            ->orderBy('sort_order')
            ->orderBy('name')
            ->paginate(20);

        return MenuCategoryResource::collection($categories);
    }

    /**
     * Store a newly created menu category.
     */
    public function store(
        StoreMenuCategoryRequest $request
    ): JsonResponse {
        $category = MenuCategory::create(
            $request->validated()
        );

        return (new MenuCategoryResource($category))
            ->response()
            ->setStatusCode(201);
    }

    /**
     * Display the specified menu category.
     */
    public function show(
        MenuCategory $menuCategory
    ): MenuCategoryResource {
        return new MenuCategoryResource($menuCategory);
    }

    /**
     * Update the specified menu category.
     */
    public function update(
        UpdateMenuCategoryRequest $request,
        MenuCategory $menuCategory
    ): MenuCategoryResource {
        $menuCategory->update(
            $request->validated()
        );

        return new MenuCategoryResource(
            $menuCategory->refresh()
        );
    }

    /**
     * Remove the specified menu category.
     */
    public function destroy(
        MenuCategory $menuCategory
    ): JsonResponse {
        if ($menuCategory->menuItems()->exists()) {
            return $this->sendError(
                'Menu category cannot be deleted because it has menu items.',
                409
            );
        }

        $menuCategory->delete();

        return $this->sendSuccess(
            'Menu category deleted successfully.'
        );
    }
}

Let's examine the important decisions.

A. Paginated listing

$categories = MenuCategory::query()
    ->orderBy('sort_order')
    ->orderBy('name')
    ->paginate(20);

return MenuCategoryResource::collection($categories);

Pagination prevents the API from returning every category in a single request. This becomes increasingly important as the database grows.

Ordering by sort_order and then name also provides predictable category ordering.

Laravel's resource collection preserves pagination metadata, although the precise JSON envelope depends on the resource configuration and Laravel version.

B. Validated input when creating a category

$category = MenuCategory::create(
    $request->validated()
);

The StoreMenuCategoryRequest handles validation before the controller method executes.

Using validated() means the controller receives only fields accepted by the request's validation rules, rather than blindly accepting every submitted field.

The model must still have the appropriate mass-assignment configuration, and authorization rules should be applied where required.

The response uses HTTP 201 Created:

return (new MenuCategoryResource($category))
    ->response()
    ->setStatusCode(201);

This communicates that a new resource was successfully created.

C. Retrieving a single category

public function show(
    MenuCategory $menuCategory
): MenuCategoryResource {
    return new MenuCategoryResource($menuCategory);
}

Laravel's implicit route model binding resolves the category from the route parameter.

For example:

GET /api/menu-categories/5

Laravel attempts to resolve the category with ID 5. If it cannot find the model, the framework normally returns a 404 Not Found response.

Returning a resource also keeps the category's JSON representation under the control of MenuCategoryResource.

D. Updating a category

$menuCategory->update(
    $request->validated()
);

return new MenuCategoryResource(
    $menuCategory->refresh()
);

The update request validates the incoming fields before the model is changed.

Calling refresh() reloads the model's current database values before constructing the response. This can be useful when the database applies defaults or other changes during persistence.

E. Preventing deletion of categories with menu items

if ($menuCategory->menuItems()->exists()) {
    return $this->sendError(
        'Menu category cannot be deleted because it has menu items.',
        409
    );
}

Deleting a category that still has associated menu items could break application behavior or violate database constraints.

The exists() query checks whether any related records exist without loading the entire relationship collection into memory.

HTTP 409 Conflict is appropriate when the requested deletion conflicts with the current state of the resource.

After the deletion check passes:

$menuCategory->delete();

return $this->sendSuccess(
    'Menu category deleted successfully.'
);

The controller reuses the shared success helper instead of constructing another custom JSON response.

Step 4: Understand Where Resources and Shared Helpers Fit

A useful distinction is that resource formatting and shared response helpers solve related but different problems.

Component	Responsibility
`AppBaseController`	Shared response helper methods
`MenuCategoryController`	Handles CRUD workflow and business rules
`StoreMenuCategoryRequest`	Validates creation input
`UpdateMenuCategoryRequest`	Validates update input
`MenuCategoryResource`	Controls how a category is represented in JSON
`MenuCategory` model	Represents the database entity and relationships

In this implementation, the listing, creation, retrieval, and update methods return Laravel resources directly, while deletion uses the shared sendSuccess() and sendError() helpers.

That matches the resource-oriented style used by the existing RoleAPIController.

However, if the project requires every successful endpoint to use ResponseUtil::makeResponse(), then the resource-returning methods should also be adapted to that convention. Before doing so, check whether the existing API expects Laravel's standard resource envelope or the custom envelope defined by ResponseUtil.

Consistency means following the actual project contract, not simply using the same method everywhere.

Step 5: Register the CRUD Routes

Laravel can register the standard API resource routes with one declaration:

use App\Http\Controllers\API\MenuCategoryController;
use Illuminate\Support\Facades\Route;

Route::apiResource(
    'menu-categories',
    MenuCategoryController::class
);

This generates the five standard API operations:

HTTP method	Endpoint	Controller method
GET	`/api/menu-categories`	`index`
POST	`/api/menu-categories`	`store`
GET	`/api/menu-categories/{menu_category}`	`show`
PUT/PATCH	`/api/menu-categories/{menu_category}`	`update`
DELETE	`/api/menu-categories/{menu_category}`	`destroy`

The actual route parameter name can depend on Laravel's resource parameter configuration. Confirm the registered routes using Artisan.

Step 6: Verify the Changes

After saving the controller, run:

php artisan optimize:clear

php artisan route:list --path=menu-categories

Then test the endpoints with Postman or your preferred API client.

Verify that:

The listing is paginated.
Invalid creation and update requests are rejected.
Successful creation returns HTTP 201.
Requests for nonexistent categories return 404.
Categories with related menu items cannot be deleted.
Successful deletion returns HTTP 200 with the shared success message.
Response structures match the conventions expected by the frontend.

You should also test duplicate category names. The controller shown here does not itself prevent duplicate creation; that behavior must be implemented through validation and appropriate database constraints.

Lessons Learned

This refactoring reinforced several backend development principles:

Reuse existing architecture. Before introducing a custom response format, inspect the conventions already used by other controllers.
Separate responsibilities. Form requests validate input, models handle persistence and relationships, resources format output, and controllers coordinate the workflow.
Use meaningful HTTP status codes. 201 indicates creation, 404 indicates a missing resource, and 409 can indicate a conflict with the resource's current state.
Avoid unnecessary database work. Relationship exists() checks can be more efficient than loading an entire collection just to count or inspect it.
Treat API responses as a contract. Frontend applications depend on predictable response shapes, pagination metadata, and error handling.

Conclusion

Refactoring MenuCategoryController to extend AppBaseController improves alignment with the existing Laravel application and makes shared response behavior easier to maintain.

The key is to reuse the project's established conventions without sacrificing validation, pagination, resource formatting, or correct HTTP semantics.

Before applying the same pattern to other controllers, inspect their response contracts and confirm whether they use Laravel resources, ResponseUtil, or a combination of both.

That small step can prevent a lot of inconsistent API behavior as an application grows.

6 Types of Information Systems: A Beginner-Friendly Guide

Vincent Tommi — Thu, 15 Oct 2026 05:00:00 +0000

Information systems help organisations collect, process, store, and share information. However, different systems serve different purposes depending on the tasks performed and the level of management involved.

In this article, we will explore six common types of information systems, their functions, and practical examples of how organisations use them.

1. Transaction Processing Systems (TPS)

A Transaction Processing System (TPS) handles the routine, day-to-day transactions of an organisation.

These systems operate at the operational level and process large amounts of basic transaction data.

Key Functions

Record business transactions.
Process routine operations.
Generate detailed reports and summaries.
Maintain accurate transaction records.

Examples

Payroll systems that calculate employee salaries.
Point-of-sale systems that record customer purchases.
Stock control systems that track inventory.
Order processing systems that record customer orders.

Practical example: When you purchase goods at a supermarket, the point-of-sale system records the sale, calculates the total, and updates stock levels.

2. Office Systems

Office systems help employees perform everyday communication, documentation, and administrative tasks.

They are widely used across different departments and support the creation, storage, and sharing of information.

Key Functions

Create and edit documents.
Manage spreadsheets and databases.
Send and receive emails.
Support communication and collaboration.

Examples

Microsoft Word for document processing.
Microsoft Excel for spreadsheets.
Email applications for communication.
Database applications for organising records.

Practical example: An administrator uses a spreadsheet to manage employee attendance and email to share reports with colleagues.

3. Knowledge Work Systems (KWS)

Knowledge Work Systems support professionals who create new knowledge, develop designs, or solve specialised technical problems.

They are commonly used by engineers, architects, designers, and other technical professionals.

Key Functions

Support technical and professional work.
Help create new designs and knowledge.
Perform modelling and simulations.
Support complex problem-solving.

Examples

Computer-Aided Design (CAD) software.
Engineering simulation tools.
Advanced scientific modelling applications.
Professional design software.

Practical example: An engineer uses CAD software to design a machine component before it is manufactured.

4. Management Information Systems (MIS)

A Management Information System (MIS) provides managers with organised information to monitor operations and make routine management decisions.

MIS commonly uses summary data generated by Transaction Processing Systems to produce reports.

Key Functions

Summarise operational data.
Generate regular management reports.
Highlight unusual results or exceptions.
Support planning, monitoring, and control.

Examples

Monthly sales reports.
Departmental performance reports.
Inventory summary reports.
Payroll cost reports.

Practical example: A supermarket manager reviews a monthly sales report to identify the best-selling products and departments with declining sales.

5. Decision Support Systems (DSS)

A Decision Support System (DSS) helps users analyse information and evaluate possible solutions to problems.

Unlike systems that mainly report past activities, DSS can help users explore different scenarios and predict possible outcomes.

Key Functions

Analyse data using statistical methods.
Compare alternative decisions.
Perform what-if analysis.
Use models and simulations to evaluate possible outcomes.

Examples

Spreadsheets used for financial forecasting.
Investment analysis tools.
Sales forecasting applications.
Inventory optimisation systems.

Practical example: A business manager uses a spreadsheet to compare how different product prices might affect revenue and profit.

A DSS supports decision-making; it does not necessarily make the final decision for the user.

6. Executive Support Systems (ESS)

Executive Support Systems provide senior managers with high-level information for strategic planning and long-term decision-making.

They combine information from internal systems with relevant external information, such as market conditions, competitor activities, and economic trends.

Key Functions

Present high-level organisational performance.
Combine internal and external information.
Identify long-term trends.
Support strategic planning and major business decisions.

Examples

Executive dashboards.
Strategic performance reports.
Market trend analysis tools.
Business intelligence dashboards for senior leadership.

Practical example: A company's chief executive reviews sales trends, competitor performance, and economic forecasts to decide whether the business should expand into a new market.

7. Comparison of the Six Information Systems

System	Main purpose	Typical users
TPS	Process routine transactions	Operational staff
Office Systems	Support communication and office tasks	Employees across departments
KWS	Support technical work and knowledge creation	Engineers, designers, and specialists
MIS	Produce management reports	Middle managers
DSS	Analyse alternatives and support decisions	Professionals, analysts, and managers
ESS	Support strategic decisions	Senior executives

8. How the Systems Work Together

These information systems are not isolated. They can share information and support different levels of an organisation.

For example, in a retail business:

TPS records daily sales.
MIS summarises sales data into monthly reports.
DSS analyses different pricing and stock scenarios.
ESS uses business performance and market trends to support expansion decisions.

Office systems help employees communicate and manage documents, while knowledge work systems support specialised tasks such as product design.

Together, these systems help an organisation operate efficiently, analyse performance, and plan for the future.

Conclusion

The six types of information systems serve different purposes, from recording everyday transactions to supporting strategic decisions.

Understanding their differences helps explain how information flows through an organisation and how employees, managers, and executives use information to perform their responsibilities.

Key takeaway: TPS handles transactions, office systems support daily office work, KWS supports specialised knowledge work, MIS produces management reports, DSS evaluates alternatives, and ESS supports strategic decisions.

Knowing these six types and their examples is useful when studying Information Systems and preparing for examinations.