Birdie Planning Report

CIS 591 Planning Report: ‘Birdie’
Benjamin Kreeger
(816) 806-7096
kreeger545@missouristate.edu

Table of Contents

Part I: Background
...............................................................................3
Company information
3
System name and brief description
3
System stakeholders
3
Description of existing system
4
Initial technological assumptions
5
Implemented use case: define customer
6
Initial requirement assumptions
9
Event table
9
Problem domain classes
10
Development methodology & architecture
10
Ultimate disposition of project
10

Part II: System Benefits
.....................................................................11
Tangible benefits of new system
11
Intangible benefits of new system
11

Part III: Project Schedule & Costs
....................................................13
Phases, activities, tasks, and person-hours
13
Project Costs
16

Part IV: Feasibility Study
...................................................................18
Organizational feasibility
18
Cultural feasibility
18
Technological feasibility
18
Schedule feasibility
18
Resource feasibility
18
Economic feasibility
19
Overall feasibility
19

Part V: Project Monitoring / Reporting to Date
...............................20

2
CIS591: Planning Report

Part I: Background

Part I: Background
Company information
National Marketing Resources Darrin Clawson, Chief Information Officer
341 W. Washington dclawson@nmrdirect.com
Kearney, MO 64060 (816) 903-6177

National Marketing Resources is a company operating in the consulting and marketing
industries, and offers its various services to entrepreneurs, investors, and small business
owners. They’re a “sister company” to Professional Marketing International, which operates
out of Utah. Together (operations between the two companies are highly integrated) they
employ close to 300 between Kearney, MO; Provo, UT; and a satellite sales office in Phoenix,
AZ.

System name and brief description
The information system I will be planning and developing for National Marketing Resources
(“NMR”) has been given the working name Birdie, simply for the reason that NMR enjoys
naming its systems after golf jargon. It is a sales leads tracking system that computerizes the
process of obtaining and categorizing sales leads from various marketing campaigns and
then forwarding them to marketers, who then follow through on those leads and upgrade their
statuses to accounts.

As leads come into our company, either through a mass import or an individual lead, it comes
in through another company, which is the lead source. That source also has several
promotions, and a lead is classified under that promotion as well. Each promotion has
various marketing campaigns, which could be surveys, infomercials, etc., and leads care
classified under those categories and placed into a buyer pipeline or a non-buyer pipeline.
This classification taxonomy is called the lead path. As the leads are imported, they’re each
classified into lead paths for reporting purposes. Those leads each get passed down through
management to our various sales companies, which each have divisions, and each division
has multiple smaller teams, each team with a handful of marketers. Each manager at each
level assigns their leads where they want them, and marketers log in to the system to retrieve
those leads and modify their statuses and details as needed. Management at any level will
pull a plethora of reports based on this information to determine how much marketers are
selling, how many calls they’re making, how profitable each sales company/team/division is,
and so forth.

System stakeholders
The owners of the company (Steve Thorne and Boyd Kanenwisher) are both stakeholders in
this project, obviously, as they will get reports with information based on sales leads statistics.
Sales managers are also stakeholders as they and their marketers will be prime users of this
software. The Processing department will also have a stake in the system as they’re the one
processing leads and forwarding them to the marketers. The system will only be used
internally, so there are no external stakeholders.

3

Part I: Background

Description of existing system
The existing system is known as LINKS. It allows for the importing of sales leads and the
managing of those leads, including forwarding them to marketers and maintaining the status
of those leads. It imports data from various sales campaigns run by our clients, and also
allows for manual input of leads as well. Those leads are then placed into a list and allocated
to several of our individual sales companies, and then into teams, and on to individual
marketers as well.

LINKS only runs on local Windows client workstations. If a user wishes to use the client
software but they don’t have it installed on their workstation, they must ﬁrst have all the
prerequisite software installed (including report viewers, .NET Frameworks, etc). In the
interest of accessing this system from any computer, regardless of operating system and
location, this system can be modiﬁed and written as a web application with added
functionality. With the right framework and architecture, the program can be built for easy
expansion in the future as well.

In speaking with Darrin Clawson, NMR’s CIO, I learned that the demand for an iPhone or
mobile phone app is growing within the company. Many associates have iPhones, or other
phones with the ability to browse the web. Instead of locking down the software to run on
iPhones (as would be the case with a native iPhone application), we could instead have one

4

Part I: Background
web application that works the same on modern mobile phones as it does in a desktop web
browser.

Initial technological assumptions
The new system will be built using the Django web framework, which is built upon Python. It
will use a MySQL database backend. The design will be done using object-oriented design
principles (Django uses object-relational mapping between the Python code and the SQL
database). As Django loosely follows the model-view-controller pattern, design will be in
three layers.

Initially the system will not be integrated with the existing LINKS system. This functionality
could be added later. This project will perform some of the same functionality as LINKS, while
adding others as well, and perhaps most importantly, the ability to expand to other functions
much more easily.

I’m challenging myself some initially with the technology I’ll be using for this project. I’m
already quite familiar with the workings of MySQL, and I’m somewhat familiar with web
frameworks (I’ve done some work with Ruby on Rails before), but this will be the ﬁrst time I’ve
ever used a Python-based web framework. I don’t anticipate many problems with this,

5

Part I: Background
however, as Python compliments Java & C# (languages I’m familiar with) more than Ruby
does. I’m currently reading The Definitive Guide to Django, which was written by one of the
creators of Django, and I have another book on my shelf as well titled Practical Django
Projects, which details using development methodologies when creating a Django web
application. The online documentation for the language is also very robust and descriptive.
Any snags I may run into while coding the project should be easily resolved.

Implemented use case: define customer

The use case I implemented is the define customer use case. The screenshot you see above
is a form from a basic administration page allowing changes to a customer in the database.
When a customer’s information has been edited and successfully updated in the database,
the user is sent back to a list of all available customers from the database, along with a
banner at the top telling them their update is complete.

6

Part I: Background

The code representing my database’s connection information is defined in my Django site’s
master settings file, settings.py. That database connection code is shown below.

DATABASE_ENGINE = 'mysql'
DATABASE_NAME = 'birdie'
DATABASE_USER = 'birdie'
DATABASE_PASSWORD = 'birdie'
DATABASE_HOST = '/tmp/mysql.sock'
DATABASE_PORT = ''

The SQL command is being executed behind-the-scenes (Django’s database API handles that
for me using object-relational mapping). The model (and database structure) is defined in the
models.py file as shown below.

7

Part I: Background

from django.db import models
from django.contrib.localflavor.us.models import USStateField, PhoneNumberField

class Customer(models.Model):
first_name = models.CharField(max_length=50)
last_name = models.CharField(max_length=50)
address = models.CharField(max_length=100)
city = models.CharField(max_length=60)
state = USStateField()
zip = models.CharField(max_length=10)
country = models.CharField(max_length=50)
phone = PhoneNumberField()

def __unicode__(self):
return '%s %s' % (self.first_name, self.last_name)

The database structure is below, along with the data from the database. The result is shown
in PHPMyAdmin.

8

Part I: Background

Initial requirement assumptions
Event table

Event Trigger Source Use Case Response Destination
Processing wants to Management
New lead source Processing rep Define lead source Lead source
create a lead source Processing
enter a lead in New lead Processing rep Create new lead Lead Processing
manually Marketers
import a batch of Batch lead import Processing rep Import external leads Leads Processing
leads Marketers
New promotion Processing rep Define promotion Promotion
create a promotion Processing
Processing wants to New marketing Define marketing Management
Processing rep Marketing campaign
create a campaign campaign campaign Processing
Processing wants to
Batch assign lead Assign leads to lead Management
classify leads to a Processing rep Categorized lead(s)
paths path Marketers
path
Processing chooses Sales company
Distribute leads to Leads assigned to
sales company to Assign leads Processing rep management
sales company sales company
receive leads Marketers
Sales company
management wants Sales company Distribute leads to Leads assigned to Division management
Assign leads
to distribute leads to management division division Marketers
divisions

Division management
Distribute leads to Leads assigned to Sales teams
wants to distribute Assign leads Division management
sales team sales team Marketers
leads to teams

Sales teamleaders
want to assign leads Assign leads to Leads assigned to
Assign leads Sales teamleaders Marketers
to individual marketers marketers
marketers
Marketer follows up Upgrade/downgrade Lead with changed Marketers
Lead properties Marketer
on lead lead status status Sales teamleaders
Time to archive Updated archived
‘End of day’ Archive inactive leads
inactive leads leads list
Any level of
Management (any Customized lead Management (any
management wants a Report request Generate lead report
level) report level)
lead report
Any level of
management wants a Management (any Generate marketer Customized marketer Management (any
Report request
report on certain level) report performance report level)
marketer(s)
Sales company
management wants a Sales company Generate overall Master performance Sales company
Report request
report on overall management report report management
performance
Processing needs a
Export leads Processing rep Export lead list Exported lead data Processing rep
master list of leads
Processing needs to Marketers
add or change a Edit customer Processing rep Define customer Modified customer Management (any
customer’s details level)

9

Part I: Background

Problem domain classes

• Lead Source • Promotion • Pipeline
• Sales Company • Division • Team
• Marketer • Lead • Product
• Event • Order

Development methodology & architecture
I’ll be using the Unified Process as the development methodology for this project. UML
diagrams will be built based on a master list of use cases as well (both requirements and
design models).

The project, in accordance with the coding principles of Django, will follow the model-view-
controller architecture. Django actually uses a slightly different variant of this architecture,
called the model-template-view architecture. The Django framework handles the controller
layer using a URL configuration file for the project, and views become the business logic of
the project. These views render templates, which are the presentation layer. Models are still
the database logic and schema.

Ultimate disposition of project
My sponsor (Darrin Clawson) will be somewhat involved in the project. He and the chief
software architect of the current LINKS system (Michael Battey) will offer guidance as to the
elementary business processes I’ll need to map out. It’s more of a prototype system based
on the idea of a web-based retooling to the existing system. Our office has been
incorporating some Macs into daily operations lately, and more and more associates of the
companies are using mobile phones with full-fledged Internet browsers. They’ll need a way to
access functions of the system from their non-Windows computers, or even their mobile
phones. This system should serve as a prototype of how that system can work, although
whether it will be implemented once the project is completed is doubtful. I have complete
control over the system’s abilities and scope.

10


Tangible benefits of new system
The following are assumed tangible benefits of using the new system over using the old
system. Assumptions made are those that each lead lost costs the company an average
$1,000 of revenue, and that on average, 300 leads are lost due to improperly importing or
assigning them. Also assumed is a 10% growth in the number of leads handled each year.

Year 1
Reduction of possible errors in leads handling (revenue from lost leads) $300,000
Increased efficiency in processing department (2 people @ $30,000) $60,000
Added savings from database hosting costs $6,000
Added savings from development costs ($800 Visual Studio x 5) $4,000
Year 1 total $370,000

Year 2
Reduction of lead handling errors (revenue from lost leads) $330,000

Year 3
Reduction of lead handling errors (revenue from lost leads) $363,000
Added savings from dev environment upgrades $4,000

3-year grand total $1,079,000

The current system in place does provide benefits over the old way of handling leads (which
was printing out an Excel spreadsheet and cutting them into paper strips containing lead
information). Plenty of money has been and will continue to be saved with this new system.
In fact, the new system will allow users to store their generated reports for future retrieval.
Costs for database hosting is based off of retail cost of Microsoft SQL Server 2008, which is
currently used to host many of our databases, including the application database for LINKS.
Moving to MySQL will drastically reduce, or even eliminate, those costs.

Intangible benefits of new system
Perhaps one of the greatest intangible benefits of the new system is the increased
accessibility. With the Internet being accessible in more and more places, as well as
increases in coverage from high-speed cellular data networks like 3G and EVDO, the new
system can be accessible from any Internet connected device at any time, as opposed to
being tied to a client workstation or laptop at home or in the office.

11

In addition to accessibility, the new system will be platform-independent, so regardless of the
OS of the client (be it Windows, Linux, Mac OS X, or any specialized mobile platform), as long
as there’s an web browser, the system can be accessed.

Another intangible beneﬁt is the ability for easier expansion. The system will be written in
Python, using the Django framework, which allows for easy scalability and expansion. Extra
functionality can be developed on any machine with Python and Django installed, and then
activated in mere seconds on the production server.

12


Phases, activities, tasks, and person-hours

Business modeling 19
Understanding the business environment 6
Research problems with current system 2
Identify stakeholders 1
Determine integration with other systems 1
Understand new system’s place with existing system architecture 2
Create the system vision 6
Identify system objectives 2
Determine system capabilities 2
Identify benefits 2
Create business models 7
Create organizational chart 1
Create sales lead workflow model 2
Create computing infrastructure diagram 2
Create marketer lead processing workflow model 2

Requirements 63
Gather detailed information 12
Gather existing documentation on work processes 3
Review existing LINKS system 4
Get information about desired reports 2
Observe users of current LINKS system 3
Define functional requirements 18
Write detailed use case descriptions 7
Create use case diagram(s) 2
Create problem domain class diagram 2
Create interaction diagrams 7
Define nonfunctional requirements 6
Define security requirements 1
Define reliability requirements 1
Define technological requirements 2
Define usability requirements 2
Prioritize requirements 5
Determine core requirements 2
Plan other requirements per iteration 2
Set aside some requirements for future releases 1
Develop user interface dialogs 15
Create storyboards for each use case 8
Determine color scheme 1
Create mockups for overall site design (desktop browsers) 3
Create mockups for mobile site design 3
Evaluate requirements with users 7

13

Interview users regarding requirements 4
Revise requirements based on interviews 2
Remove unnecessary requirements 1

Design 139
Design the support services architecture and deployment environment 5
Plan for server operating systems 2
Design internal site access vs. external site access 2
Determine periodic system upgrade plan 1
Design the software architecture 8
Establish model-template-controller components 5
Design package diagrams 3
Design use case realizations 72
Create design class diagram 4
Create expanded sequence/interaction diagrams 8
Implement core use cases 40
Implement non-core use cases 20
Design the database 7
Finalize domain class diagram 2
Use domain class diagram to define schema 2
Specify relationships between tables 2
Determine if integration with other DBs is necessary 1
Design the system and user interfaces 35
Markup storyboards as necessary 2
Define Django templates 20
Design reports and forms 10
Choose system fonts 2
Determine links and integrations to other systems if necessary 1
Design the system security and controls 12
Determine security groups and users 2
Determine access levels for each group 2
Determine system administrators 2
Design login area 4
Set an encryption level 2

Implementation 90
Build software components 85
Write view logic 40
Write models 10
Write presentation templates 20
Write URL configurations 10
Write settings file 5
Integrate software components 5
Upload changes from test server to production server 5

Testing 38
Define and conduct unit testing 14

14

Define unit tests to be done 4
Carry out unit tests on core system functions 4
Carry out unit tests on extra features 2
Carry out unit tests on system security 4
Define and conduct integration testing 8
Define integration tests to be done (core functions must always work) 4
Carry out integration testing on each part of system as it’s built 4
Define and conduct usability testing 4
Compare storyboards with actual system interfaces 2
Determine ease-of-use with users 2
Define and conduct user acceptance testing 12
Have users test core functions for acceptance 6
Have users test extra features for acceptance 6

Deployment 42
Acquire hardware and system software 8
Download server operating system 2
Download MySQL Server 1
Download Django framework 1
Obtain server hardware 4
Package and install components 7
Install server OS on hardware 2
Install MySQL Server on server 1
Install Django framework on top of Python 1
Install all upgrades as necessary 2
Setup Apache with mod_python 1
Train users 21
Develop training documentation for system 10
Distribute training documentation 1
Implement documentation within system 5
Hands-on training sessions with users 5
Convert and initialize data 6
Import needed geographical data 2
Import initial batch of leads 2
Add users and security groups to the system 2

Project Management 35
Evaluate the project’s scope and risk 10
Determine project scope with use case list 4
Create problem domain class list 2
Determine project risk 2
Identify any possible threats to progress of project 2
Confirm the project’s feasibility 9
Calculate net present value 2
Calculate rate of return on project 2
List costs per year of system 2
Develop payback analysis 2

15

Complete feasibility study section of planning report 1
Develop the project and iteration schedules 9
List out all tasks as required by project 6
Discuss direction of project schedule with Dr. Satzinger 1
Determine tasks to be done per iteration 2
Monitor and control the project’s iterations 7
Log time worked on all tasks 2
Keep a journal of everything done per day 2
Adjust project schedule / iterations as necessary 2
Develop periodic deliverable reports for Dr. Satzinger 1

Conﬁguration and Change Management 8
Develop change control procedures 4
Keep daily backups of all code and documentation 2
Develop plan for moving code to production server 2
Manage models and software components 4
Update models as project evolves 2
Keep documentation on changes to code (versioning) 2

Environment 47
Select, conﬁgure, and understand the development tools 34
Establish programming software (obtain and install) 2
Establish software needed for model creation, diagramming 2
Learn Python / Django as needed 30
Tailor the UP development process 10
Lay out and setup project deliverables 4
Meet with Dr. Satzinger as often as needed 5
Determine which models to develop and include in deliverables 1
Provide technical support services 3
Answer questions of any test users 3

Grand Total of Hours 481

Project Costs
I’ve determined that I’ll be charged $35.00/hour for my development services (similar to a
salary of $72,800). That would make labor costs for developing the system $16,835. I’m also
assuming that the time required to maintain the system will be roughly half of the time spent
developing it (just over 240 hours), and that time may increase by about 20% each year due
to aging system specs and adding new features. I’m also assuming that I’ll be the only
person working on developing and maintaining this new system.

Software licensing costs will be next to nothing, as most of the software used in implementing
the system is open-sourced (with the exception of word-processing programs, spreadsheet
software, diagramming applications, and the like). That should allow us more money from
whatever budget we’re operating on to be focused on hardware and other supplies.

16

Due to the size of the company as far as number of users go (675 users maximum, assuming
current employment numbers of almost 300 and adding 50% yearly growth for 3 years), I’m
allowing roughly $20,000 per year to be spent on server equipment like blades, as well as
development materials like laptops or desktops.

Dev Costs/
Hourly Rate Year 0 Year 1 Year 2 Year 3 Total

$ 25.00 $ 32,025.00 $ 26,012.50 $ 27,215.00 $ 28,658.00 $ 113,910.50

$ 30.00 $ 34,430.00 $ 27,215.00 $ 28,658.00 $ 30,389.60 $ 120,692.60

$ 35.00 $ 36,835.00 $ 28,417.50 $ 30,101.00 $ 32,121.20 $ 127,474.70

$ 40.00 $ 39,240.00 $ 29,620.00 $ 31,544.00 $ 33,852.80 $ 134,256.80

$ 45.00 $ 41,645.00 $ 30,822.50 $ 32,987.00 $ 35,584.40 $ 141,038.90

$ 50.00 $ 44,050.00 $ 32,025.00 $ 34,430.00 $ 37,316.00 $ 147,821.00

17


I. Organizational feasibility
I don’t believe there to be a lot of risk in terms of the organization. Nobody’s going to be
changing positions, and nobody’s going to be eliminated from their positions by this system
(not as far as the system is planned out). A similar system is already in place, and most
organizational changes took place when that system was implemented (very few changes
were made). The previous project, and the current one, are both quite organizationally
feasible. 10/10.

II. Cultural feasibility
This feasibility category, along with organizational feasibility, doesn’t carry a lot of risk with it.
Nobody’s afraid of computers; in fact, so many people are embracing them (and different
types of them) that looking into a project like this has been requested. If anything, staff and
management will have even more control (especially in our sales companies) over what and
how much their people are doing than before. 10/10.

III. Technological feasibility
Technological feasibility could be an issue. I’m not too familiar with Django, and I’m even less
familiar with the Python language it’s written in (I’m currently learning both, however, quite
quickly). If this were being implemented in an actual company environment (as opposed to
doing this in a individual project environment), I’d request that we hire a couple of people that
already know Django and Python to assist in developing the project, and perhaps more
importantly, in supporting it once it’s ﬁnished. I’m keeping an eye on this one. 6/10.

IV. Schedule feasibility
Seeing as I have all semester to complete the project (with various milestones along the way
requiring deliverables to help keep me on track), I don’t think time will be too much of an
issue. Most of my schedule is open (I’m only taking one other 3-credit-hour class, and I work
roughly 20-30 hours a week at my on-campus IT job), so I’ll be able to devote good portions
of time on this project. It will be important to for me gauge how far along I am in the project
by determining how many hours I’ve worked and how many use cases I’ve implemented in
code, and so forth, so I’ll be keeping an eye on this category as well. 7/10.

V. Resource feasibility
The users are there, currently using the old system; I can tap them as needed to ask them any
questions I need. The major issue with this category is that I’m the only ‘staff member’
assigned to doing this project. I’m the planner, the analyst, the programmer, the tester, and
manager. I have people I can call on if I need technical help, and I can use my professor as a
resource, but this also could be a problem. 5/10.

18


VI. Economic feasibility

Costs/
benefits Year 0 Year 1 Year 2 Year 3 Total
Value of
$ 370,000.00 $ 336,000.00 $ 373,000.00
benefits

Discount factor
1 0.9000 0.8100 0.7290
(10%)

Present value of
$ 333,000.00 $ 272,160.00 $ 271,917.00 $ 877,077.00
benefits

Dev costs $ (36,835.00) $ (36,835.00)

Ongoing costs $ (28,417.00) $ (30,101.00) $ (32,121.20)

Present value of
$ (25,575.30) $ (24,381.81) $ (23,416.35) $ (73,373.46)
costs

PV of net of
$ (36,835.00) $ 307,424.70 $ 247,778.19 $ 248,500.65
benefits, costs

Cumulative NPV $ (36,835.00) $ 270,589.70 $ 518,367.89 $ 766,868.54

decimal: 0.1198
Payback period $36,835.00 / (36,835.00 + 270,589.70)
days: 44

3-year return on
($877,077.00 - (36,835.00 + 73,373.46)) / (36,835.00 + 73,373.46) 695.83%
investment

I wasn’t quite sure originally, but it looks like this project is quite economically feasible! If
there was any area where I’d have to second-guess my calculations, it would be on the costs
of the system; however, since I’m the only one being paid labor hours to do this project, labor
costs are very low. 10/10.

VII. Overall feasibility
If I total up my arbitrary scores for each feasibility category, I’d get a figure that says this
project is 80% feasible. I’d definitely recommend that the project continue, as it seems most
areas of feasibility recommend it.

19


Week #
Hours Actual
Allotte Hours
Activities d 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Worked
Business modeling
Understanding the business environment -
Research problems with current system 2 1 1 2
Identify stakeholders 1 1 1
Determine integration with other systems 1 1 1
Understand new system’s place with existing system
2 2 2
architecture
Create the system vision
Identify system objectives 2 1 1 2
Determine system capabilities 2 1 1 2
Identify benefits 2 1 1 2
Create business models
Create organizational chart 1 0
Create sales lead workflow model 2 0
Create computing infrastructure diagram 2 0
Create marketer lead processing workflow model 2 0
Requirements
Gather detailed information
Gather existing documentation on work processes 3 1 2 3
Review existing LINKS system 4 2 2 4
Get information about desired reports 2 1 1 2
Observe users of current LINKS system 3 0
Define functional requirements
Write detailed use case descriptions 7 0
Create use case diagram(s) 2 0
Create problem domain class diagram 2 0
Create interaction diagrams 7 0
Define nonfunctional requirements
Define security requirements 1 1 1
Define reliability requirements 1 1 1
Define technological requirements 2 1 1
Define usability requirements 2 1 1
Prioritize requirements
Determine core requirements 2 1 1 2
Plan other requirements per iteration 2 1 1 2
Set aside some requirements for future releases 1 0
Develop user interface dialogs
Create storyboards for each use case 8 0
Determine color scheme 1 0
Create mockups for overall site design (desktop
3 0
browsers)
Create mockups for mobile site design 3 0
Evaluate requirements with users
Interview users regarding requirements 4 2 2
Revise requirements based on interviews 2 0
Remove unnecessary requirements 1 0
Design

20

Week #
Hours Actual
Allotte Hours
Design the support services architecture and
deployment environment
Plan for server operating systems 2 1 1 2
Design internal site access vs. external site access 2 2 2
Determine periodic system upgrade plan 1 0
Design the software architecture
Establish model-template-controller components 5 0
Design package diagrams 3 0
Design use case realizations
Create design class diagram 4 0
Create expanded sequence/interaction diagrams 8 0
Implement core use cases 40 3 3
Implement non-core use cases 20 0
Design the database
Finalize domain class diagram 2 0
Use domain class diagram to define schema 2 1 0.5
Specify relationships between tables 2 0
Determine if integration with other DBs is necessary 1 0
Design the system and user interfaces
Markup storyboards as necessary 2 0
Define Django templates 20 0
Design reports and forms 10 0
Choose system fonts 2 0
Determine links and integrations to other systems if
1 0
necessary
Design the system security and controls
Determine security groups and users 2 0
Determine access levels for each group 2 0
Determine system administrators 2 0
Design login area 4 0
Set an encryption level 2 0
Implementation
Build software components
Write view logic 40 0
Write models 10 1 1
Write presentation templates 20 0
Write URL configurations 10 1 1
Write settings file 5 1 1
Integrate software components
Upload changes from test server to production server 5 0
Testing
Define and conduct unit testing
Define unit tests to be done 4 0
Carry out unit tests on core system functions 4 0
Carry out unit tests on extra features 2 0
Carry out unit tests on system security 4 0
Define and conduct integration testing
Define integration tests to be done (core functions must
4 0
always work)

21

Week #
Hours Actual
Allotte Hours
Carry out integration testing on each part of system as
4 0
it’s built
Define and conduct usability testing
Compare storyboards with actual system interfaces 2 0
Determine ease-of-use with users 2 0
Define and conduct user acceptance testing 12 0
Have users test core functions for acceptance 6 0
Have users test extra features for acceptance 6 0
Deployment
Acquire hardware and system software
Download server operating system 2 0
Download MySQL Server 1 0
Download Django framework 1 0
Obtain server hardware 4 0
Package and install components
Install server OS on hardware 2 0
Install MySQL Server on server 1 0
Install Django framework on top of Python 1 0
Install all upgrades as necessary 2 0
Setup Apache with mod_python 1 0
Train users
Develop training documentation for system 10 0
Distribute training documentation 1 0
Implement documentation within system 5 0
Hands-on training sessions with users 5 0
Convert and initialize data
Import needed geographical data 2 0
Import initial batch of leads 2 0
Add users and security groups to the system 2 0
Project Management
Evaluate the project’s scope and risk
Determine project scope with use case list 4 2 2 4
Create problem domain class list 2 2 2
Determine project risk 2 2 2
Identify any possible threats to progress of project 2 2 2
Confirm the project’s feasibility
Calculate net present value 2 2 2
Calculate rate of return on project 2 2 2
List costs per year of system 2 2 2
Develop payback analysis 2 2 2
Complete feasibility study section of planning report 1 1 1
Develop the project and iteration schedules
List out all tasks as required by project 6 4 2 6
Discuss direction of project schedule with Dr. Satzinger 1 1 1
Determine tasks to be done per iteration 2 0
Monitor and control the project’s iterations
Log time worked on all tasks 2 0 0 0 0 0 0 0.6
Keep a journal of everything done per day 2 0 0 0 0 0.4
Adjust project schedule / iterations as necessary 2 0

22

Week #
Hours Actual
Allotte Hours
Develop periodic deliverable reports for Dr. Satzinger 1 0 0.1
Conﬁguration and Change
Management
Develop change control procedures
Keep daily backups of all code and documentation 2 0 0 0 0 0 0 0.6
Develop plan for moving code to production server 2 0
Manage models and software components
Update models as project evolves 2 0
Keep documentation on changes to code (versioning) 2 0
Environment
Select, conﬁgure, and understand the
development tools
Establish programming software (obtain and install) 2 2 2
Establish software needed for model creation,
2 1 1 2
diagramming
Learn Python / Django as needed 30 4 4 4 3 5 20
Tailor the UP development process
Lay out and setup project deliverables 4 2 1 1 4
Meet with Dr. Satzinger as often as needed 5 1 1 1
Determine which models to develop and include in
1 0
deliverables
Provide technical support services
Answer questions of any test users 3 0
Grand Total of Hours 493 98.2

23

Birdie Planning Report

More Related Content

Viewers also liked (11)

Similar to Birdie Planning Report (20)

More from Benjamin Kreeger (16)

Recently uploaded (20)

Birdie Planning Report