From First-Time Coders to a Working Prototype

After eight weeks of learning, debugging and building, our students reached an important milestone: a working prototype of the Youth Job Bank.

Many of our students entered the program with little or no experience building software. Over the course of eight weeks, we worked through HTML, CSS, Python, Django, databases, GitHub, Agile development and the debugging process that connects all of those pieces together.

For the final portion of the program, we brought those skills together and began building something much larger: a Youth Job Bank.

What We Managed to Build

This was no longer a collection of individual HTML exercises. By the end of the project, students had started building many of the same components found in a real web application.

Turning Database Records Into a Website

One of the biggest milestones was our job listing page.

Instead of creating a separate piece of HTML for every job, Django could retrieve job records from the database and use the same template to display each one. That is an important transition from building a static website to building a dynamic web application.

It Was Starting to Feel Like a Real Product

Some sections of the website received enough styling that the project was beginning to develop its own identity.

Our homepage and About page were good examples. They were no longer simply demonstrating whether the backend worked. We were beginning to think about layout, messaging, usability and how someone would actually experience the application.

Functionality Came Before Polish

Other areas showed exactly where we ran out of time.

The employer registration form, for example, was functional but had not yet received the CSS and Bootstrap styling that we would have wanted for a finished product.

That actually demonstrates something important about software development: working functionality and visual polish are separate stages of the process.

The employer registration workflow was working, but the page still needed frontend styling.

Authentication Was Working Too

Users were also able to log into the application. That may look simple from the browser, but it introduces an important backend concept.

Once users can authenticate, our application can begin answering two different questions:

• Who is this user?
• What should this user be allowed to do?

Those questions become especially important when one user is an employee looking for work and another is an employer posting jobs.

We Built Around the Core Application Too

We also created supporting sections of the website such as the About and Contact pages. These helped students see that a complete application is made up of many smaller pieces working together.

Prototype Is Not the Same as Production

One of the last lessons of the project was understanding just how much work exists between "it works on my computer" and "real people can safely use this."

If we wanted to turn our Youth Job Bank prototype into an actual public service, development would continue in several areas.

There Was Still Plenty Left to Do

That is an important part of the story.

We did not finish a commercial job platform in eight weeks. That was never a realistic expectation.

What we did accomplish was taking a group of young, largely first-time developers through the process of turning an idea into a substantial working prototype.

They experienced much more than simply writing a few lines of code.

• They wrote code that worked.
• They wrote code that did not work.
• They learned how to read errors and debug problems.
• They worked with a database.
• They connected frontend pages to backend logic.
• They created and authenticated users.
• They dynamically displayed information from Django.
• They used GitHub and began working like a development team.
• They saw how a larger application can be divided into smaller problems.

Learn. Build. Launch.

That brings our eight-week development program to a close.

We started by learning how individual pieces of technology work. We finished by seeing how those pieces can be assembled into software that solves a real problem.

Eight weeks, plenty of debugging, and one very promising Youth Job Bank prototype.