Home / Software Development / What Is Software?
Software Basics

What Is Software?

Your screen can show a successful booking before a confirmation email arrives. Are those the same piece of software working?

Software is the organised set of instructions, rules and data that turns electronic hardware into something useful. It decides what a phone does after a tap, how an ATM checks a withdrawal and how a website remembers an order. This guide separates software from hardware, follows instructions from interface to stored result and explains why useful software must be maintained, secured and corrected long after its first release.

6 min read
What Is Software? — original ExplainItSimply topic illustration

By

A booking service may save a reservation, queue a message and let a separate worker send the email. These steps communicate but need not finish together.

The screen should report the saved booking accurately while the email process handles retries. One late message does not necessarily mean the reservation failed.

The confirmation email failed. Does that mean your booking failed too?

A website can save a reservation successfully and then fail to send its email. If it reports only 'something went wrong', a customer may try again and create another booking. The screen, saved record and notification describe different states.

Follow that ordinary failure to understand software as coordinated instructions and decisions. We will identify what must be recorded, what can be retried and what the customer should be told. You do not need to learn a programming language to reason about the result.

Practical examples: What Is Software

Phone

A phone app combines visible screens with permissions, local storage, network requests and operating-system services. A camera app, for example, must request access to hardware, process the captured image and save it without exposing private files to unrelated applications.

ATM

An ATM is software controlling physical machinery under strict financial rules. It reads the card, protects the PIN, checks the account through a banking network, controls the cash dispenser and records the result. If cash fails to dispense, the transaction must not quietly remove money from the account.

School

School software can enrol learners, schedule classes, capture attendance, store marks and generate reports. Different roles see different functions: a learner reads results, a teacher records work and an administrator manages official data. Those permissions are part of the software, not merely the screen design.

Online

An online service continues working after the browser closes because its important data lives on servers. The page on your device is one participant in a larger system that may include APIs, databases, identity services, payment providers, monitoring and backups.

Why can an app show old information while its server is healthy?

Software often keeps copies to avoid repeating expensive work.

Trace the explanation

A cache improves speed but introduces a freshness decision. Understanding which component owns the current value helps explain why refreshing one screen sometimes changes the result.

Source and further reading: MDN Web Docs

A successful button tap can still hide an unfinished job

A booking screen can display 'sent' before the server has saved anything. The interface knows that it dispatched a request; only the receiving system can confirm what it accepted. Software has to keep those different states separate if it is to give an honest answer.

Follow one booking: the browser collects dates, the server checks availability, the database records the reservation, and the response supplies a reference. An email may be queued afterward. If email fails, the reservation should not silently disappear, and if the response is lost, repeating the action should not create a second booking.

Booking B42 saved to Retry its notification, not the booking1: Booking B42 saved. 2: Email attempt fails. 3: Retry its notification, not the booking.1Booking B42 saved2Email attempt fails3Retry its notification, not thebooking

Separate the business outcome from its follow-up message

The server validates the request, saves booking B42 and records that a confirmation email is pending. The email service is temporarily unavailable, so the reservation stays confirmed while the notification remains pending.

When email becomes available, the system can retry the message using the recorded work. It should not create a second booking merely to obtain another chance at sending mail. The interface can show the stable booking reference and an honest notification status.

A single boolean called success cannot express every useful state here. Software needs a model of the outcome and rules for the next action. This is where an apparently simple button becomes a small workflow.

Separate the business outcome from its follow-up message — worked evidence
FactState
Booking B42 savedConfirmed
Email attempt failedNotification pending
Safe retryRetry notification, not purchase

The email is retried three times, but booking creation happened once. How many booking records should this workflow contain?

This checks a prediction about the worked example. It does not run server code, contact an API or change a booking.

Read the explanation without the checker

One. A message retry should refer to the existing booking rather than recreate the purchase. Actual systems need an explicit duplicate-prevention design.

Apply the same reasoning to a receipt that arrives late. Which record should establish whether the payment happened?

Further context: Separate the business outcome from its follow-up message

Why the idea matters

Thinking in systems explains why software changes can have unexpected effects. A small field added to a screen may require an API contract change, a database column, validation, reporting updates and deployment coordination. Good software development tries to understand those connections before changing one layer.

Where readers often get confused

Software is not finished simply because it works once. Real products need maintenance, security updates, monitoring, backups, performance work and adaptation as user needs and surrounding technologies change.

Software has a life after launch

Once people depend on a system, developers have to care about observability and operations. Logs reveal failures, metrics show response time or resource pressure, backups protect data and deployment processes decide how a new version reaches users. A feature can be correct in a developer environment and still fail in production because of configuration, permissions, load or an external service.

That ongoing responsibility is why maintainability matters. Clear boundaries between interface, business logic and data access make it easier to change one part without accidentally rewriting everything. The best architecture is not the one with the most layers. It is the one that makes the system’s important responsibilities understandable and testable.

A toy app refreshes its copy every 5 minutes. Ignoring other delays, how many seconds is that interval?

Trace the explanation

5 × 60 = 300 seconds. This describes a fictional refresh policy, not a guarantee about any particular app. A changed server value can remain absent locally until the next successful refresh.

Worked relationship: 5 × 60 = 300 seconds. 5: minutes; 60: seconds per minute; 300: seconds between refreshes

Source and further reading: MDN Web Docs

Why does restarting an app fix some problems but not others?

Restarting clears temporary process state. It does not automatically repair a wrong record in a database or change a rule in the program.

If a stale screen disappears after reopening, local state may have been involved. If the same wrong value returns from the server, investigate the stored data and the logic producing it.

Move from the finished product to the instructions behind it

Continue with what programming means to see how people define software behaviour, then open the source-code guide to understand where those decisions are recorded. If you want to follow one complete online action, trace a real production feature through its layers.

The invisible work begins when the happy path ends

Imagine the last available unit being requested by two people. Both may have seen an available card moments earlier. A reliable system makes the final allocation safely where shared data is controlled, rather than assuming the first screen remains true forever.

This is why software is more than screens and calculations. It includes rules for simultaneous actions, recovery, access and evidence of what happened. A useful acceptance question is not only 'does this work?' but 'what should the user see if the connection fails after the save?' That question turns an attractive demo into a service someone can depend on.

Should a page say 'booking confirmed' because the spinner stopped?

No. Confirmation should depend on a successful server outcome with a stable reference, not on the animation ending. A stopped spinner may only mean the browser finished waiting.

Questions about What Is Software?

Is software the same as an app?

An app is one type of software. Software is the bigger word for all digital instructions that run on computers and devices.

Can software break?

Yes. Software can have bugs, wrong settings or missing information. Developers fix and improve it over time.

What is the difference between software and hardware?

Hardware is the physical equipment. Software is the instructions and data that tell that equipment what to do.

What is an operating system?

It is foundational software that manages hardware resources and provides common services that applications can use.

Why does software need updates?

Updates can fix defects, close security vulnerabilities, support new devices, improve performance or add behaviour users need.

Software is instructions plus data plus an environment

A program does not operate in isolation. A web application depends on an operating system, runtime, configuration, network, database and often external services. The same source code can behave differently if a configuration value changes or a required service is unavailable. That is why developers distinguish between code, configuration, infrastructure and data when diagnosing a problem.

Software also has a lifecycle. Requirements become designs and code, code is tested and deployed, users expose real-world edge cases, and the system is monitored and changed over time. Maintenance is not a failure of software development. It is part of software development because the world around the program keeps changing.

You update your profile on a laptop but the phone shows the old name. Which components might need checking?

One reasoned response

Compare the server response, the phone's cached profile and whether its refresh request succeeded. Reinstalling the whole application should not be the first assumption when the problem may be an old copy.

Source and further reading: MDN Web Docs

A tiny example of software turning a rule into behaviour

Software is not only the screen you see. It includes the instructions, data and rules that decide what the screen does. Here is a small Python example of a rule a shop might use to decide whether an order qualifies for free delivery.

def delivery_cost(order_total):
    if order_total >= 500:
        return 0
    return 60

print(delivery_cost(650))  # 0
print(delivery_cost(250))  # 60

The function receives an order total and returns a delivery cost. The business rule is explicit, but a real system would also need to consider currency, valid input, delivery areas, promotions and whether the total includes discounts. This illustrates why software requirements matter: code can follow a rule exactly and still produce the wrong outcome if the rule itself is incomplete.

Sources

Sources and further reading

A closer look

One feature crosses several systems

Changing a guest name appears to be a single edit. The application may need to validate the user, update the booking, record an audit trail and notify another service.

Work through the distinction

Define which step is authoritative and what happens when a later step fails. A confirmation should describe an established result, not merely the start of a request. Good software includes recovery paths as well as the happy path.

When should the screen claim the name was saved?

Choose an answer to see feedback. You can try again.

Show the answer and explanation

After authoritative confirmation. Define which step is authoritative and what happens when a later step fails. A confirmation should describe an established result, not merely the start of a request. Good software includes recovery paths as well as the happy path.

Help us make learning clearer

Was this explanation useful?

Your rating helps us understand which explanations are working and where we can improve.

5.0/ 5·1 ratings
Community

Join the conversation

Add your perspective, ask a useful question or share what stood out.

0 comments
◌ No comments yet

This conversation is waiting for its first useful thought.