← Back to Module

Project Planning and Development

CMU422: Fundamentals of Web Design - Session 10

Birmingham Newman University

Lecturer: James Williams

Building complete web applications

3-hour session • 25 slides • 2 interactive tasks

Session Timeline:

  • 10 min: Registration & waiting
  • 20 min: Opening slides
  • 45 min: Task 1
  • 15 min: Break/Catch up
  • 20 min: Secondary slides
  • 45 min: Task 2
  • Remaining: Self-study

Learning Objectives

  • Understand project planning methodologies
  • Learn requirements gathering techniques
  • Master project structure and organization
  • Implement version control best practices
  • Build complete web applications

Project Planning Fundamentals

Project Planning is the process of defining project scope, objectives, and deliverables
  • Define project goals and objectives
  • Identify stakeholders and requirements
  • Create project timeline and milestones
  • Allocate resources and budget
  • Plan risk management strategies
// Project structure example
project-name/
  ├── src/
  │ ├── html/
  │ ├── css/
  │ ├── js/
  │ └── assets/
  ├── docs/
  ├── tests/
  └── README.md

Requirements Gathering

// Functional Requirements
- User can register and login
- User can create and edit posts
- User can upload images
- User can comment on posts
- User can search for content

// Non-Functional Requirements
- Page load time < 3 seconds
- Mobile responsive design
- Cross-browser compatibility
- Accessibility compliance
- Security requirements
  • Functional requirements (what the system does)
  • Non-functional requirements (how the system performs)
  • User stories and use cases
  • Acceptance criteria

User Stories

// User Story Format
As a [type of user]
I want [goal/feature]
So that [benefit/value]

// Examples
As a registered user
I want to create a new post
So that I can share my thoughts with others

As a visitor
I want to search for content
So that I can find relevant information quickly

As an admin
I want to moderate comments
So that I can maintain community standards
  • Focus on user perspective
  • Include acceptance criteria
  • Prioritize by business value
  • Estimate effort and complexity

Project Structure

// Recommended project structure
my-web-app/
  ├── index.html
  ├── pages/
  │ ├── about.html
  │ ├── contact.html
  │ └── dashboard.html
  ├── css/
  │ ├── main.css
  │ ├── components.css
  │ └── responsive.css
  ├── js/
  │ ├── app.js
  │ ├── utils.js
  │ └── api.js
  ├── assets/
  │ ├── images/
  │ ├── icons/
  │ └── fonts/
  ├── docs/
  ├── tests/
  └── README.md
  • Organize by file type and purpose
  • Separate concerns (HTML, CSS, JS)
  • Include documentation and tests
  • Follow naming conventions

Version Control with Git

// Initialize Git repository
git init
git add .
git commit -m "Initial commit"

// Create and switch branches
git checkout -b feature/user-authentication
git checkout -b bugfix/login-error

// Commit changes
git add .
git commit -m "Add user authentication feature"

// Merge branches
git checkout main
git merge feature/user-authentication

// Push to remote
git remote add origin https://github.com/user/repo.git
git push -u origin main
  • Track changes and history
  • Collaborate with team members
  • Branch for features and fixes
  • Rollback to previous versions

Git Workflow

// Feature Branch Workflow
1. Create feature branch from main
git checkout -b feature/new-feature

2. Make changes and commit
git add .
git commit -m "Add new feature"

3. Push to remote
git push origin feature/new-feature

4. Create Pull Request
5. Code review and merge
6. Delete feature branch

// Commit Message Convention
feat: add user authentication
fix: resolve login error
docs: update README
style: format code
  • Feature branch workflow
  • Pull request process
  • Code review practices
  • Commit message conventions

Project Documentation

// README.md structure
# Project Name

## Description
Brief description of the project

## Features
- Feature 1
- Feature 2

## Installation
```bash
git clone https://github.com/user/project.git
cd project
open index.html
```

## Usage
Instructions on how to use the application

## Technologies Used
- HTML5
- CSS3
- JavaScript

## Contributing
Guidelines for contributing to the project
  • README file for project overview
  • Installation and setup instructions
  • API documentation
  • Code comments and inline docs

Wireframing and Mockups

Wireframes are low-fidelity sketches of the user interface
  • Paper sketches for quick ideas
  • Digital tools (Figma, Sketch, Adobe XD)
  • Focus on layout and structure
  • Include user flow diagrams
  • Create responsive design mockups
// HTML wireframe example
<div class="header">
  <nav>Navigation</nav>
</div>
<div class="main">
  <section class="hero">Hero Section</section>
  <section class="content">Main Content</section>
</div>
<div class="footer">Footer</div>

Responsive Design Planning

// Mobile-first approach
/* Base styles (mobile) */
.container {
  width: 100%;
  padding: 10px;
}

/* Tablet styles */
@media (min-width: 768px) {
  .container {
    max-width: 750px;
    margin: 0 auto;
  }
}

/* Desktop styles */
@media (min-width: 1024px) {
  .container {
    max-width: 1200px;
  }
}
  • Mobile-first design approach
  • Breakpoint planning
  • Flexible grid systems
  • Touch-friendly interfaces

Development Workflow

// Development phases
1. Planning & Design
  - Requirements gathering
  - Wireframing
  - Project setup

2. Development
  - HTML structure
  - CSS styling
  - JavaScript functionality

3. Testing
  - Unit testing
  - Integration testing
  - User testing

4. Deployment
  - Code review
  - Production deployment
  - Monitoring
  • Iterative development process
  • Continuous integration
  • Testing at each phase
  • Regular code reviews

Testing Strategies

// Unit testing example
describe('Calculator', () => {
  test('adds two numbers correctly', () => {
    expect(add(2, 3)).toBe(5);
  });

  test('handles negative numbers', () => {
    expect(add(-1, 1)).toBe(0);
  });
});

// Integration testing
test('user registration flow', async () => {
  const user = await registerUser({
    email: 'test@example.com',
    password: 'password123'
  });
  expect(user.email).toBe('test@example.com');
});
  • Unit testing for individual functions
  • Integration testing for features
  • End-to-end testing for user flows
  • Manual testing and user feedback

Performance Optimization

  • Image optimization and compression
  • CSS and JavaScript minification
  • Lazy loading for images
  • Code splitting and bundling
  • Caching strategies
// Image optimization
<img src="image.jpg" loading="lazy" alt="Description">

// CSS optimization
/* Minified CSS */
.header{background:#fff;padding:20px}

// JavaScript optimization
// Use async/defer for scripts
<script src="app.js" defer></script>

// Caching headers
Cache-Control: max-age=31536000

Accessibility Planning

// Semantic HTML
<header>Site header</header>
<nav>Navigation</nav>
<main>Main content</main>
<footer>Site footer</footer>

// ARIA attributes
<button aria-label="Close dialog">×</button>
<div role="alert" aria-live="polite">Message</div>

// Keyboard navigation
element.addEventListener('keydown', (event) => {
  if (event.key === 'Enter' || event.key === ' ') {
    event.preventDefault();
    handleClick();
  }
});
  • Semantic HTML structure
  • ARIA attributes for screen readers
  • Keyboard navigation support
  • Color contrast compliance
  • Alt text for images

Security Considerations

  • Input validation and sanitization
  • Cross-site scripting (XSS) prevention
  • Cross-site request forgery (CSRF) protection
  • Content Security Policy (CSP)
  • HTTPS implementation
// Input validation
function validateInput(input) {
  if (typeof input !== 'string') {
    throw new Error('Invalid input type');
  }
  return input.replace(/[<>]/g, '');
}

// Content Security Policy
<meta http-equiv="Content-Security-Policy"
  content="default-src 'self'; script-src 'self' 'unsafe-inline'">

// HTTPS redirect
if (location.protocol !== 'https:') {
  location.replace('https:' + location.href.substring(location.protocol.length));
}

Deployment Planning

// Deployment options
- GitHub Pages (free, static sites)
- Netlify (free tier, continuous deployment)
- Vercel (free tier, serverless)
- AWS S3 + CloudFront
- Traditional web hosting

// Environment variables
const apiUrl = process.env.API_URL || 'http://localhost:3000';
const apiKey = process.env.API_KEY;

// Build process
npm run build
npm run test
npm run deploy
  • Choose appropriate hosting platform
  • Set up continuous deployment
  • Configure environment variables
  • Monitor application performance

Task 1: Project Planning Exercise

Instructions:

  1. Create a comprehensive project plan for a web application
  2. Choose one of these project ideas:
    • E-commerce Website: Online store with product catalog, shopping cart, and checkout
    • Blog Platform: Content management system with user authentication and commenting
    • Task Management App: Project management tool with team collaboration features
    • Portfolio Website: Personal portfolio with projects showcase and contact form
  3. Complete the following planning documents:
    • Project overview and objectives
    • User stories and requirements
    • Wireframes and mockups (paper or digital)
    • Project structure and file organization
    • Technology stack and dependencies
    • Development timeline and milestones
  4. Set up version control with Git
  5. Create initial project structure
  6. Write comprehensive README.md

Time: 45 minutes

This task will help you understand project planning and organization

Break Time

15 Minutes

Take a break, ask questions, or catch up on the previous task.

Next: Secondary slides and Task 2

Agile Development

  • Sprint planning and backlog management
  • Daily standups and progress tracking
  • Sprint reviews and retrospectives
  • Continuous improvement
// Sprint planning example
Sprint 1 (Week 1-2):
- User authentication system
- Basic navigation structure
- Homepage layout

Sprint 2 (Week 3-4):
- Product catalog
- Shopping cart functionality
- User profile management

Sprint 3 (Week 5-6):
- Checkout process
- Payment integration
- Order management

Code Quality and Standards

  • Coding standards and style guides
  • Code review processes
  • Linting and formatting tools
  • Documentation requirements
// ESLint configuration
{
  "extends": ["eslint:recommended"],
  "rules": {
    "indent": ["error", 2],
    "quotes": ["error", "single"],
    "semi": ["error", "always"]
  }
}

// Prettier configuration
{
  "tabWidth": 2,
  "singleQuote": true,
  "trailingComma": "es5"
}

Team Collaboration

  • Communication tools and platforms
  • Code sharing and pair programming
  • Conflict resolution strategies
  • Knowledge sharing practices
// Branch naming conventions
feature/user-authentication
bugfix/login-error
hotfix/security-patch
release/v1.0.0

// Commit message format
feat: add user authentication
fix: resolve login error
docs: update README
style: format code

// Pull request template
## Description
Brief description of changes

## Testing
Steps to test the changes

## Checklist
- [ ] Code follows style guidelines
- [ ] Tests pass
- [ ] Documentation updated

Project Monitoring

  • Progress tracking and metrics
  • Issue tracking and bug reports
  • Performance monitoring
  • User feedback collection
// Issue tracking template
## Bug Report
**Description:** Brief description of the bug
**Steps to reproduce:**
1. Step 1
2. Step 2
3. Step 3
**Expected behavior:** What should happen
**Actual behavior:** What actually happens
**Environment:** Browser, OS, etc.

// Performance monitoring
// Google Analytics
gtag('config', 'GA_MEASUREMENT_ID');

// Custom performance tracking
performance.mark('app-start');
performance.measure('app-load', 'app-start');

Task 2: Complete Web Application

Instructions:

  1. Build a complete web application based on your project plan from Task 1
  2. Implement all planned features and functionality
  3. Follow best practices:
    • Code Organization: Modular structure with separate concerns
    • Version Control: Regular commits with meaningful messages
    • Testing: Unit tests for core functionality
    • Documentation: Comprehensive README and code comments
    • Responsive Design: Mobile-first approach
    • Accessibility: WCAG compliance
  4. Include advanced features:
    • User authentication and authorization
    • Data persistence (localStorage or mock API)
    • Form validation and error handling
    • Search and filtering functionality
    • Responsive navigation and layout
    • Performance optimization
  5. Deploy the application to a hosting platform
  6. Create a presentation showcasing your work
  7. Prepare for code review and feedback

Time: 45 minutes

This task will help you understand complete web application development

Session Summary

  • Project planning is essential for successful development
  • Version control enables collaboration and history tracking
  • Testing ensures quality and reliability
  • Documentation helps maintain and scale projects
  • Performance and accessibility are crucial for user experience
  • Continuous improvement leads to better outcomes

Next Session:

Advanced Topics and Future Trends - Exploring modern web development