Understanding Software

Think of it like a recipe

A recipe tells a cook how to make a dish, step by step. Code tells a computer how to perform a task, step by step. If a step is missing or wrong, the result is wrong too.

It's everywhere

Email, Instagram, banking apps, your car dashboard, smart TVs, traffic lights. All powered by software. Just instructions running on different hardware.

Runs locally

On your own computer or phone. Like Microsoft Word or a desktop app. Only you can see and use it.

Runs in the cloud

On a remote server somewhere. Like Gmail or Netflix. Anyone with access can reach it over the internet.

A typical project

my-website/
  index.html          main page
  style.css           visual design
  app.js              interactivity
  package.json        project config
  images/
    logo.png
    hero.jpg

What this means

• A "codebase" is the collection of all project files
• Some files are logic, some are design, some are configuration
• You can open and read any file in a text editor
• Changes to one file can affect others

Configuration

Files like package.json or .env that control how the project behaves, what tools it uses, and what settings it needs.

Dependencies

Pre-built libraries the project relies on. Like buying ingredients from a store instead of growing them yourself. Saves time, creates reliance.

Environment Variables

Secret settings like API keys and passwords. These should never be shared publicly or committed to code repositories.

What it is

• Built with HTML (structure) + CSS (style)
• Maybe a little JavaScript for interactivity
• No database, no user accounts, no backend
• Content is the same for every visitor

Examples

• Portfolio or personal website
• Restaurant menu page
• Product landing page
• Event invitation or info page

Dynamic website

• A server processes each request
• Content is customized per visitor
• Requires a backend + database
• Example: news site, e-commerce store

Full web application

• User accounts, saved data, interactions
• Payments, real-time features, admin panels
• Multiple interconnected systems
• Example: Slack, Airbnb, Google Docs

Mobile apps

• Run on phones (iOS, Android)
• App store approval process required
• Device compatibility testing
• Push notifications, offline mode, permissions
• May need separate codebases per platform

Enterprise platforms

• Multiple services working together
• Teams of engineers to build and maintain
• Compliance, auditing, SLAs
• Think: Uber, Shopify, Salesforce
• Months or years to build properly

HTML - Structure

Defines what's on the page: headings, paragraphs, images, buttons, links, forms.

The skeleton and bones of a building.

<h1>Welcome</h1>
<p>This is a paragraph.</p>
<button>Click me</button>

CSS - Style

Defines how it looks: colors, fonts, spacing, layout, animations, responsive design.

The paint, furniture, and interior design.

h1 {
  color: navy;
  font-size: 2rem;
}
button {
  background: blue;
  border-radius: 8px;
}

What it does

• Makes web pages interactive (clicks, animations, live updates)
• The only language that runs natively in web browsers
• Also runs on servers via Node.js
• Powers both frontend and backend
• Largest ecosystem of libraries and tools

What it looks like

// Show a greeting when button is clicked
function greet(name) {
  return `Hello, ${name}!`;
}

button.addEventListener('click', () => {
  alert(greet('World'));
});

What it does

• Dominant in AI, machine learning, and data science
• Great for backend development
• Excellent for automation and scripting
• Beginner-friendly syntax
• Huge ecosystem of scientific and web libraries

What it looks like

# Calculate a discount
def apply_discount(price, percent):
    discount = price * (percent / 100)
    return max(price - discount, 0)

result = apply_discount(100, 15)
print(f"Final price: ${result}")
# Output: Final price: $85.0

Frontend: The Dining Room

Everything the user sees and interacts with.

• Buttons, forms, layouts, animations
• Built with HTML, CSS, JavaScript
• Frameworks: React, Vue, Angular
• Runs in the user's browser

Backend: The Kitchen

The behind-the-scenes logic the user never sees.

• Processes requests, enforces rules
• Talks to databases and external services
• Built with Python, Node.js, Go, Java
• Runs on a server

Think of it as...

A very powerful, structured spreadsheet that code reads from and writes to automatically. Each table is like a sheet. Each row is a record. Each column is a field.

Common examples of stored data

• User profiles (name, email, password hash)
• Products (title, price, stock quantity)
• Orders (items, total, shipping address)
• Messages, settings, activity logs

Reading data

-- Find all orders over $100
SELECT customer_name, total
FROM orders
WHERE total > 100
ORDER BY total DESC;

-- Count users by country
SELECT country, COUNT(*)
FROM users
GROUP BY country;

How data is structured

Tables with rows and columns, just like a spreadsheet. Tables can reference each other through relationships.

Database connections

• Each request to the database opens a connection
• Connections are limited and cost resources
• "Connection pooling" reuses connections efficiently
• Too many connections = database overload

User sessions

• When you log in, the server creates a "session"
• A token (cookie) identifies you on each request
• Sessions expire for security (that's why you get logged out)
• Managing sessions properly is critical for security

Undo button

Something broke? Revert to the last working version instantly. No work is ever truly lost.

History book

See exactly what changed, when, and why. Full audit trail of your entire project's evolution.

Collaboration

Multiple people can work on the same project. Git merges changes and resolves conflicts.

What Git gives you

• Branches let you experiment without risking working code
• Commits are checkpoints you can always return to
• Pull requests enable code review before changes go live
• Blame shows who wrote each line and when

GitHub / GitLab

• Cloud storage for your Git repositories
• Your laptop dying does not mean your project dies
• Free for personal and small team use
• Industry standard for all software teams

Common frameworks

• React / Next.js - web user interfaces
• Express / FastAPI - backend servers
• Tailwind CSS - styling and design
• React Native - mobile apps from web code
• Django / Rails - full-stack web apps

The trade-off

• Every library is a dependency
• Dependencies can become outdated or abandoned
• Security vulnerabilities in a library affect your app
• Updating one can break others
• More dependencies = more risk over time

Domain

Your internet address
myapp.com

~$10-50/year

Hosting

A server that runs your app 24/7

$0-500+/month

Deployment

Moving code from your machine to the server

Can be automated via CI/CD

Unit tests

Test individual functions in isolation. Like checking each ingredient before cooking.

test("10% off $100", () => {
  expect(discount(100, 10))
    .toBe(90);
});

Integration tests

Test that pieces work together. Does the frontend correctly save data to the database?

The recipe produces a good dish, not just good ingredients.

End-to-end tests

Test the full user journey. User signs up, creates a profile, makes a purchase.

Simulates real behavior in a real browser.

Removing duplication

• The "DRY" principle: Don't Repeat Yourself
• Duplicated code means fixing the same bug in multiple places
• Shared functions reduce errors and save time
• Example: one validation function used everywhere, not copy-pasted code

Separation of concerns

• Each part of the code should have one job
• Display logic separate from business logic
• Data access separate from data processing
• Makes it possible to change one layer without breaking others

What makes software scalable

• Efficient database queries - indexes, avoiding N+1 queries
• Caching - store frequent results to reduce load
• Stateless design - any server can handle any request
• Modular architecture - services can scale independently

Warning signs

• Page loads getting slower as data grows
• Database queries that scan entire tables
• Everything tightly coupled into one giant codebase
• No monitoring or alerting in place

Regulations you must know

• GDPR (Europe) - fines up to 4% of annual revenue
• CCPA (California) - user data rights
• Data residency requirements by country
• Right to deletion requests
• Cookie consent and tracking disclosures

Real consequences

• Legal liability and potential fines
• Loss of user trust (permanent damage)
• Mandatory breach notifications
• Potential lawsuits
• Reputation damage that's hard to recover from

The problem

• You don't understand the architecture
• No documentation explaining how things work
• No tests to verify fixes don't break other things
• Original developer is unavailable

The prevention

• Keep your software as simple as possible
• Document key decisions and architecture
• Write tests for critical paths
• Have a technical person you can call

Common problems

• Hardcoded values baked into the code instead of being configurable
• Tightly coupled logic where everything depends on everything else
• No reusability with the same code copied in multiple places
• Mixed concerns where business rules are tangled with display logic

The cost

• Adding a new feature requires rewriting existing ones
• Changing one thing breaks three other things
• What takes 1 hour to build takes 20 hours to modify
• Eventually, it's cheaper to start over from scratch

Hosting

Hosting is rent. It never stops.

Databases

More data + more users = higher costs.

What needs ongoing work

• Dependencies need updating regularly
• Security patches must be applied
• Bugs need fixing as users report them
• APIs you depend on change or get deprecated
• Browsers and devices keep evolving

Budget for it

• 10-20% of initial build cost per year
• Unpatched software gets hacked
• Abandoned software degrades over time
• The world changes around it even if you don't touch it

What they do

• Write code from plain English descriptions
• Read existing code and make changes
• Generate boilerplate, tests, and documentation
• Debug and explain code

How they work

• Large language models trained on billions of lines of code
• Sophisticated pattern matchers, not true understanding
• Work best with clear instructions and common patterns
• Can be confidently wrong

Handles well

• Static websites and landing pages
• Simple features with common patterns
• Boilerplate code and configuration
• Explaining code and finding bugs
• Writing tests for existing code
• Prototypes and proof of concepts

Falls short on

• System architecture and design decisions
• Security and compliance requirements
• Complex business logic edge cases
• Long-term maintainability
• Performance optimization at scale
• Novel problems with little training data

Before writing a single line

• Define the problem clearly and specifically
• Identify your target user and their needs
• Research existing solutions
• Determine: static site, dynamic, or full app?
• Estimate costs before building

Without a plan you get

• Scope creep that never ends
• Features nobody asked for
• Costs that spiral out of control
• A product that solves the wrong problem
• Wasted time and money

Option 1

Hire or consult a technical architect for critical decisions

Option 2

Find a technical co-founder who complements your skills

Option 3

Invest in learning the fundamentals yourself over time

Concepts to learn

• How databases and SQL work
• How APIs work (request / response)
• How authentication works (sessions, tokens)
• How deployment works (CI/CD)
• Security fundamentals (OWASP top 10)

Resources

• freeCodeCamp - free, structured courses
• The Odin Project - full-stack web development
• CS50 (Harvard) - computer science fundamentals
• MDN Web Docs - web technology reference
• OWASP - security best practices