1. Overview of information system development
An information system collects, stores, processes and shares information to help people decide and work. Building one is a project with stages. Together the stages are called the development process or life cycle.
- Plan (analysis): find the real need and write the requirements.
- Design: decide how it will work.
- Build (develop): make it.
- Test (evaluate): check it.
- Run and maintain: use it and keep it healthy.
Teams may do the stages in one long line (a waterfall style) or in many small rounds (an agile style). In small rounds, users see a working piece early and give feedback. Either way the main stages stay the same.
Who is involved
Users and the client (who need it), analysts (understand the need), designers, developers, testers and operators.
2. Information system design
Design turns requirements into a blueprint. Good design answers these questions.
- Data: what facts are stored (student name, date, present/absent)? How are they organised (tables, fields)?
- Process: what steps change data into results (mark attendance, count days, find students below 75%)?
- Screens and reports: what will the user see and press? Sketch them. Make them simple and the same everywhere.
- Rules and security: who may see or change data? What happens if the internet fails? How is data backed up?
- Tools: which hardware, software and network will be used?
Tools used in design are flowcharts, data tables and screen sketches (mock-ups). Fixing a mistake here costs far less than fixing it after the system is built.
3. Developing and evaluating information systems
Develop (build)
Developers set up the database, write the program, and make the screens, following the design. They build in small parts and keep notes (documentation).
Test and evaluate
- Unit test: does each small part work?
- Integration test: do the parts work together?
- User test: real users try real tasks.
- Check against requirements: does it do everything that was asked? Is it fast, easy and safe enough?
Faults found go back to Build to be fixed, then tested again. Evaluate also means asking users how they feel and measuring results (for example, minutes saved per day).
4. Operating and maintaining information systems
Operation
The system goes live. Users are trained, old data is moved in, and operators watch that it is running, backed up and secure. Sometimes the old and new systems run together for a short time to reduce risk.
Maintenance
- Corrective: fix faults found in use.
- Adaptive: change it when the outside world changes (new rules, new phone version).
- Improving: add new features users ask for.
- Preventive: update and clean up so it does not fail later.
When a system can no longer meet needs at a fair cost, it is replaced, and the cycle starts again with a new plan.
Try it
At home: pick a small job you do on paper (for example a home shopping list or sports team scores). Write the need, the data you store, two screens you would draw, and one test you would run with a friend.
In the 3D: press "Next stage" until the token reaches Test. Then press "Fault found" and see where it goes back to.
Key formulas and definitions
- Stages: Plan → Design → Build → Test → Run and maintain (then repeat)
- Fault found in test → go back to Build
- Cost of a mistake rises the later it is found
- Maintenance kinds: corrective, adaptive, improving, preventive
Worked examples
1. A school wants an attendance app. Which stage is "ask teachers what they need and write it down"?
Plan (analysis). We find the need and write the requirements before designing.
2. During testing, the app crashes when 50 students are marked at once. Which stage does the team go back to, and why?
Build. The fault is in the program, so developers fix it and then test again.
3. A fault costs 1 hour to fix at the design stage, 10 times that after building, and 100 times that after the system is running. How many hours after running?
1 × 100 = 100 hours. This shows why we plan, design and test carefully.
Common mistakes
- Starting to build before understanding the need. The result may be useless.
- Skipping testing to save time. Faults then appear when real users are depending on it.
- Thinking the work ends when the system goes live. Maintenance is a big part of its life.
- Writing no notes. Later nobody knows how the system works.