Project Management & Consulting

Our Project Manager will be accountable for the whole project from beginning and responsible for the success of project, long term projects should opt for Project Management and Consulting Services with Vision Vivante as we are Professional, Strong in Communication and Technically enabled to take the project successfully through the various SDLC (Software Development Cycles) stages as client may not have dedicated time or knowledge.

Typically a Project Manager with Vision Vivante are alias for Client and they arrange and execute all the processes while the funding for all the resources is secured by client, to give you a clear idea, below are major tasks a PM does in course of a Project:

1. Specifications / Requirements / RFP

a. Was thought given to the system administration functionality (CMS)?
b. Was thought given to error handling?
c. Does the specification clearly segregate the project into phases?
d. Do all the phases have verifiable (and preferably undisputable) outcomes?
e. Are all the phases shorter than a month? (1-3 weeks is optimal)
f. During writing, are all unfinished parts clearly marked with (preferably red) "XXX" markers?
g. Does the document refer to other documents as specifically as possible?(Document title, revision, page number)
h. If there are interfaces, are the necessary data format specifications, API documentations all collected?
i. Is the maximum load, bandwidth and cpu usage estimated?
j. Are the security requirements specified?
k. Are the operation and maintenance requirements specified?
l. Are the education/training requirements specified?
m. Are the installation/migration requirements specified?
n. Is everything else collected? (Is there a brand manual? Color guide? Design manual? Deployment requirements? The firm's ISO procedures? Related legislation?)
o. Are all the items (use cases, etc) atomic, and (where possible) measureable?("fast" vs "10 sec")
p. Is the specification the shortest and simplest possible, while still complete?(Will it be actually read by stakeholders?)

2. Price quote / Bid

a. Are the specifications accepted by all stakeholders?
b. Does every (1-3 weeks long) phase have a price quote?
c. Are all outcomes/deliverables of phases clearly defined and testable (Payments are going to be based on these!)?
d. Has the architecture and framework of the system already been decided (At a minimum, programming languages and frameworks)?
e. Will the allocated initial capital and the payment schedule together cover costs for the project's lifetime?
f. Is there a quote for education/training?
g. Is there a quote for installation/migration?
h. Is there a quote for documentation (operating manual, user guide, etc)?
i. Is there a quote for operations and maintenance (Projects rarely end with typing in the last line of code.)?
j. Is the contract attached?
k. Who's going to own the software that is about to be developed?

3. Project start

a. Is the project still feasible?
b. Are the specifications still the same as at the time of the last price quote?
c. Has the client signed the contract (Not "promised he will sign". Actually signed.)?
d. Are there developers and a project leader assigned to the project (Testers? Designer? Other experts as needed?)?
e. Do we have a reachable and decision-capable contact person at the client?
f. Does the development team have consensus and clear vision about what will be the final delivery?
g. Does everybody on the team know *as much as possible* about the client, the project, the constraints and the deadline?

4. Checklists for development

a. General principles

i. Does everyone remember the KISS principle ("Keep it simple, stupid") and Occam's razor ("the simplest explanation or strategy tends to be the best one")?
ii. Are unfinished/unpolished parts of the code clearly marked with "XXX"?
iii. Is UTF-8 used for everything, including Databases. Tables. DB connections. Strings. Content-type. All should be UTF-8?
iv. Are compilation and any code generation automated (Makefile, Ant, Maven, etc.)?
v. Does every piece of input that comes from an untrusted source (i.e. the user, or other systems) gets filtered (Invalid characters, invalid type, etc)?
vi. Do we prevent the users from uploading dangerous files (php, cgi, exe, etc)?
vii. Are all forms validated for consistency on the server side (And, as needed, on the client side)?
viii. Are all the files in the project use the same identation (Tabs vs spaces, ident size, etc.) K&R/1TBS style is preferred?
ix. Is the code sufficiently (but not overly) commented?

b. Task Tracking

i. Does the team (or better, the company) has a task tracking system in place? ii. Is the task tracking system painless enough to use, does it help the job, or gets in the way? iii. Is the task tracking system viewed often enough (daily) both by team members and management (If not, how could you make it so)? iv. Can everybody assign tasks to everybody (I.e., developers assigning tasks to management and sales)? v. Is there some way to request acceptance testing?

c. Source control

i. Is the project using source control (It must be. No buts.)?
ii. Is it easy to create a full working instance after checkout/clone (Add an ./ for setting permissions, Makefile for code generation, etc.)?
iii. Is there a database initialization script in the repository (Database structure must be under source control, too.)?
iv. Do people pull/fetch/update before committing (Most source control systems force you to, but not all. One should always integrate before commit.)?
v. Does every commit contains only one modification (a feature, a bug fix, etc)?
vi. Does every commit have a description (Nobody will remember in three months what "today's work" was.)?
vii. Was the new code tested (and automated tests run) before committing (At some places, the person who commits code that breaks the compilation/autotests has to pay for next day's coffee/dinner.)?
viii. If the database needed changing, was the db creation script modified and committed (preferably, together with the code changes)?

5. Testing

a. Does the system have automated tests (It seems like a waste of time, but good tests save a lot of time in the long run, especially during the end, when it will matter most.)?
b. Are the tests under source control?
c. Do the tests work the system on as many components as possible (i.e., for web-based systems tests that use the user interface directly are better than unit tests, since the former also tests the communication and the client-side javascript.)?
d. Are the tests work in a test database, that gets reset at the start to a known state?

6. Checklist for operations and maintenance

a. Is there an automated monitoring/alert system in place?
b. Will you know if the automated monitoring system breaks down (Is something watching the automated monitoring system)?
c. Were the development features (error/exception display, default passwords, etc) deactivated in the deployed code?
d. Does every operational project has one person who is responsible?
e. Is that responsible person subscribed (email or RSS) to the security list of all the technologies used in that project?
f. When making small modifications to operational code or configuration, is it always clearly noted why and when the modification happened, who did it, who asked for it, and, if feasible, what was the original?
g. Are abandoned/dead projects taken offline?

All Above Listed Activities


Till (Project End +1 Month)