Common Mistakes in Software Design & Development

44 common pitfalls across 11 concepts, including 11 recurring stuck points

These are the pitfalls students hit across all 11 software design & development concepts, from Pseudocode, Flowchart and Design Specification onward. Each entry names the concept it comes from, so you can tell a slip from a genuine gap and go straight to the explanation.

1
Pseudocode
Stuck Point

There's no single 'correct' pseudocode format. It just needs to be clear and unambiguous to the reader.

2
Pseudocode
Mistake

Making pseudocode too language-specific by including syntax details like semicolons, brackets, or type declarations

3
Pseudocode
Mistake

Writing pseudocode that is too vague—each step should be clear enough that someone else could translate it to real code

4
Pseudocode
Mistake

Skipping pseudocode entirely and jumping straight to coding, which often leads to logic errors that are harder to fix later

5
Flowchart
Stuck Point

Diamonds are for decisions (yes/no questions) only. Rectangles are for actions/processes.

6
Flowchart
Mistake

Using the wrong shapes—diamonds must be for decisions only, rectangles for processes, ovals for start/end

7
Flowchart
Mistake

Creating flowcharts with missing arrows or dead ends where the flow has nowhere to go

8
Flowchart
Mistake

Making flowcharts too detailed or too abstract—aim for a level of detail that matches your audience

9

A spec describes what the system does, not how it's coded internally. Implementation details come later.

10

Writing vague requirements like 'the system should be fast' instead of measurable ones like 'pages load in under 2 seconds'

11

Including implementation details (which database to use, which framework) in a document that should focus on what, not how

12

Not involving end users or stakeholders in the specification process, leading to a spec that misses real needs

13

Agile doesn't mean 'no planning.' It means shorter cycles with frequent feedback, not chaos.

14

Skipping the requirements or design phase and jumping straight to coding, which leads to building the wrong thing

15

Treating the SDLC as purely linear—even in waterfall, you may need to revisit earlier phases when requirements change

16

Confusing agile with 'no process'—agile has structure (sprints, reviews, retrospectives) but emphasizes flexibility and feedback

17
Documentation
Stuck Point

Don't document what the code does (the code itself says that). Document why it does it — the reasoning and decisions.

18

Writing comments that restate the code instead of explaining the reasoning behind it

19

Letting documentation become outdated as code changes (stale docs are worse than none)

20

Documenting only happy paths and ignoring error handling and edge cases

21
Code Maintenance
Stuck Point

Maintenance isn't just fixing bugs — it includes adapting to new requirements, improving performance, and preventing future problems.

22

Neglecting to update dependencies, leaving known security vulnerabilities unpatched

23

Making changes without understanding the existing code, introducing new bugs while fixing old ones

24

Rewriting working code from scratch instead of incrementally improving it, which is almost always riskier and more expensive

25
Version Control
Stuck Point

A commit is a snapshot of your project at a point in time, not a copy of the whole project. Git stores differences, not duplicates.

26

Making very large commits that bundle unrelated changes, making it hard to review or revert individual changes

27

Writing vague commit messages like 'fixed stuff' instead of describing what was changed and why

28

Not pulling the latest changes before starting work, leading to merge conflicts that could have been avoided

29
Interface
Stuck Point

An interface describes what a module does and how to use it, not how it is implemented internally.

30
Interface
Mistake

Exposing internal details that other modules should not depend on

31
Interface
Mistake

Changing an interface without updating the code that depends on it

32
Interface
Mistake

Leaving inputs or error cases unspecified so the contract is ambiguous

33
Edge Cases
Stuck Point

An edge case is not the same as an invalid case. Some edge cases are valid inputs that still need the correct output.

34
Edge Cases
Mistake

Testing only normal cases and skipping empty, zero, or maximum values

35
Edge Cases
Mistake

Treating every unusual input as invalid instead of deciding whether it is a valid boundary case

36
Edge Cases
Mistake

Writing code that assumes at least one item exists without checking

37
Unit Testing
Stuck Point

A unit test should focus on one behavior at a time. If it depends on half the program, it is no longer a small isolated test.

38
Unit Testing
Mistake

Writing tests that depend on external state instead of isolating the unit

39
Unit Testing
Mistake

Combining many behaviors into one large test so failures are hard to diagnose

40
Unit Testing
Mistake

Updating production code without rerunning the unit tests

41
User Interface
Stuck Point

UI (what it looks like) is not the same as UX (how it feels to use). A beautiful UI can still be frustrating to use.

42

Overloading the interface with too many options and controls, overwhelming the user

43

Being inconsistent with design patterns—using different button styles or navigation patterns on different screens

44

Not providing feedback after user actions, leaving users uncertain whether their action was registered