Faculty of Coding and Development

Developing web apps involves both frontend and back end coding. Our training curriculum covers frontend development with react and backend with node.js.

FRONTEND DEVELOPMENT

React Frontend Development Curriculum

1. Foundation in Web Development

• HTML & CSS: Understanding the structure and styling of web pages, including best practices, responsive design, and accessibility.
• JavaScript Essentials: Covering core concepts like variables, functions, loops, arrays, and objects. This foundation is crucial for working effectively with React.

2. Advanced JavaScript

• ES6+ Syntax: Learning modern JavaScript syntax, such as let, const, arrow functions, destructuring, spread/rest operators, and template literals.
• Asynchronous JavaScript: Mastering promises, async/await, and how to work with APIs. This will be essential for data fetching in React.
• Object-Oriented & Functional Programming: Understanding how to structure JavaScript code effectively using both paradigms.

3. Introduction to React

• React Basics: Learning about React’s component-based architecture and how to create functional and class components.
• JSX: Understanding JSX syntax and how it differs from HTML.
• Props and State: Passing data between components (props) and managing component-specific data (state).
• Event Handling: Managing user interactions within React components, such as clicks and form submissions.
• Lifecycle Methods: Learning the different phases of a React component’s lifecycle and using methods like componentDidMount (class components) and useEffect (functional components).

4. React Hooks

• useState: Managing local state within functional components.
• useEffect: Handling side effects in functional components.
• Custom Hooks: Building reusable logic by creating custom hooks, helping organize code and improve modularity.
• Other Core Hooks: Learning additional hooks like useRef, useContext, and useReducer for more advanced scenarios.

5. State Management

• React Context API: Managing state globally within a small to medium-sized application.
• Redux Toolkit: An introduction to Redux for larger applications where state management becomes complex, covering concepts like the store, actions, reducers, and middleware.
• React Query (or TanStack Query): Handling server state (data fetched from APIs), caching, synchronization, and automatic refetching for an efficient data management experience in React.

6. Styling in React

• CSS-in-JS Libraries: Libraries like Styled Components or Emotion that allow you to style React components directly within JavaScript.
• Tailwind CSS: Utility-first CSS framework for efficient styling and responsive design.
• CSS Modules: Scoped, component-level styling for React components.

7. Routing

• React Router: Setting up multi-page navigation, learning concepts like routes, Link, NavLink, useNavigate, and route parameters.
• Protected Routes: Creating routes that require authentication or other conditions to access.

8. Data Fetching and API Integration

• RESTful APIs with Axios or Fetch API: Connecting to external APIs, managing data requests and responses, and error handling.
• GraphQL: An introduction to GraphQL and using Apollo Client for advanced data querying if your school includes this.

9. Testing in React

• Jest: A JavaScript testing framework, focusing on writing unit tests for components.
• React Testing Library: Testing components in a way that mimics real user interactions, like clicks and typing.
• End-to-End Testing: Using tools like Cypress to automate tests for user journeys across the app.

10. Build Tools and Deployment

• Webpack and Vite: Learning bundlers and dev server setups, or using Create React App as an abstraction for quick React setup.
• Version Control with Git: Using Git for version control, committing changes, branching, and collaborating on code.
• Continuous Integration (CI): Introducing tools like GitHub Actions or GitLab CI for automated testing and deployment pipelines.
• Hosting Platforms: Deploying React applications to platforms like Vercel, Netlify, or AWS Amplify, and managing environment variables for secure deployment.

11. Advanced React Topics (Optional)

• Server-Side Rendering (SSR) and Static Site Generation (SSG): Using frameworks like Next.js for optimized performance and SEO.
• Performance Optimization: Techniques like code splitting, lazy loading, and memoization to improve application performance.
• TypeScript with React: Adding static typing to React components and state management, which enhances code reliability.

12. Project Work and Portfolio Building

• Capstone Projects: Developing a fully functional app that demonstrates learned skills. Projects could include e-commerce, social media dashboards, or productivity tools.
• Portfolio: Building a personal portfolio site to showcase projects, code quality, and skills to potential employers.

By the end of the course, you’ll have a solid understanding of the entire React development workflow, from basic component structure to deploying a fully functional app.

• Duration: 8 months (6 hours per week)
  Schedule: 2 classes per week, scheduled with you.
• Cost: ₦ 576,000 ₦ 349,500 (Three hundred and forty-nine thousand, five hundred Naira only)

BACKEND DEVELOPMENT

Node.js Backend Development Curriculum

Module 1: Introduction to Node.js and JavaScript Basics

• Introduction to Node.js:

  • Overview of Node.js and its use cases
  • Installing Node.js and NPM
  • Setting up a development environment

• JavaScript for the Backend:

  • ES6+ syntax (arrow functions, destructuring, template literals)
  • Modules and import/export in Node.js
  • Asynchronous JavaScript: Callbacks, Promises, and Async/Await

Module 2: Core Node.js Modules and File System 

• Core Modules:

  • Introduction to core modules (fs, path, http, os)
  • Working with the file system using fs module (CRUD operations)
  • Creating and handling HTTP servers with the http module

• Working with NPM:

  • Understanding package.json and package-lock.json
  • Installing, updating, and managing packages with NPM
  • Setting up basic scripts for automation

Module 3: Building REST APIs with Express.js 

• Introduction to Express.js:

  • Setting up an Express server
  • Middleware in Express: custom and third-party
  • Route handling: GET, POST, PUT, DELETE

• RESTful API Design:

  • Structuring endpoints and routes
  • Understanding REST principles
  • Handling query parameters, route parameters, and request bodies

• Error Handling and Logging:

  • Handling common errors and status codes
  • Centralized error handling
  • Logging requests and errors using libraries like Morgan or Winston

Module 4: Database Integration with MongoDB 

• Introduction to Databases:

  • SQL vs. NoSQL databases
  • Setting up MongoDB and MongoDB Atlas

• CRUD Operations with MongoDB:

  • Basic CRUD operations using MongoDB shell
  • Introduction to Mongoose (ODM for MongoDB)
  • Defining models, schemas, and data validation

• Data Relationships:

  • One-to-many, many-to-many relationships in MongoDB
  • Populating nested data in Mongoose
  • Embedding vs. referencing documents

Module 5: Authentication and Authorization 

• User Authentication:

  • Understanding authentication vs. authorization
  • Using JSON Web Tokens (JWT) for stateless authentication
  • Implementing secure password hashing with bcrypt

• Authorization:

  • Role-based access control (RBAC)
  • Protecting routes based on user roles
  • Refresh tokens and token expiration

Module 6: Advanced API Development 

• API Security Best Practices:

  • Preventing common vulnerabilities (e.g., SQL injection, XSS)
  • Implementing rate limiting and CORS
  • Input validation and sanitization

• Advanced Topics:

  • Pagination and filtering for large datasets
  • Caching for improved performance (Redis or in-memory caching)
  • File uploads (using Multer or a cloud service like AWS S3)

Module 7: Testing and Debugging 

• Testing:

  • Unit testing with Mocha/Chai or Jest
  • Integration testing with Supertest
  • Setting up test suites and mocks

• Debugging and Profiling:

  • Debugging Node.js applications with Node Inspector and Chrome DevTools
  • Profiling performance with built-in Node tools
  • Monitoring applications in production with PM2

Module 8: Deployment and DevOps Essentials 

• Environment and Configuration Management:

  • Setting up environment variables with dotenv
  • Configuring Node.js applications for different environments (dev, prod, etc.)

• Deployment to Cloud Providers:

  • Deploying applications on cloud platforms like Heroku or DigitalOcean
  • Setting up CI/CD pipelines (GitHub Actions, GitLab CI)
  • Server management basics (PM2, Docker basics)

Module 9: WebSockets and Real-Time Communication

• Introduction to WebSockets:

  • Understanding WebSocket protocol
  • Real-time messaging using Socket.io
  • Implementing real-time features (chat, notifications)

• Integrating with REST APIs:

  • Combining REST APIs with real-time features
  • Synchronizing real-time updates with API data

Module 10: Capstone Project: Full-Featured Backend API 

• Project Setup and Planning:

  • Define a project with a real-world scenario (e.g., e-commerce backend, social media API)
  • Plan features, routes, and database models

• Building Core Features:

  • Implement core functionality with CRUD operations
  • Add user authentication, data validation, and authorization

• Implement Advanced Features:

  • Add search, filtering, and pagination
  • Implement real-time features if applicable (e.g., notifications or chat)

• Testing, Deployment, and Documentation:

  • Write unit and integration tests for core features
  • Deploy to a cloud platform with environment variables
  • Document the API with Swagger or Postman

• Duration: 8 months (6 hours per week)
  Schedule: 2 classes per week, scheduled with you.
• Cost: ₦ 576,000 ₦ 349,500 (Three hundred and forty-nine thousand, five hundred Naira only)

You could specialize in

• native mobile app development for android, 
• native mobile app development for iOS, OR
• cross platform mobile app development.

Stack Recommendations:

• Native Android: Kotlin with Jetpack Libraries for full access to Android’s latest tools and features.
• Native iOS: Swift with SwiftUI or UIKit for streamlined UI design and compatibility across the Apple ecosystem.
• Hybrid: Flutter for consistent UI and performance across platforms, or React Native for JavaScript developers aiming for cross-platform reach with reusable code.

Native Android Development (Kotlin)

Course Duration: 6 months

Module 1: Introduction to Android and Kotlin Basics 

• Overview of Android Development and Kotlin
• Setting up Android Studio and Development Environment
• Basic Kotlin Syntax: Variables, Data Types, Control Flow
• Functions, Classes, and Inheritance in Kotlin

Module 2: Android UI Design and Layouts 

• XML Layouts, Views, and ViewGroups
• ConstraintLayout, LinearLayout, and RecyclerView
• Creating Custom Views
• Responsive Design: Supporting Different Screen Sizes and Orientations

Module 3: Navigation and User Interaction

• Activity Lifecycle and Intents
• Fragments and Fragment Navigation
• Handling User Input with Forms
• Gesture Detection and Touch Events

Module 4: Data Storage and Persistence

• SharedPreferences for Simple Data Storage
• SQLite Database and Room Library for Local Data
• Data Binding and LiveData
• Saving Data and Managing State

Module 5: Networking and APIs

• Making API Calls with Retrofit
• Parsing JSON Data
• Working with RESTful APIs and Data Binding
• Offline Caching with Room and LiveData

Module 6: Advanced Android Development

• Dependency Injection with Dagger/Hilt
• Coroutines and Asynchronous Programming in Kotlin
• Jetpack Compose Basics (optional module for UI modernization)
• App Performance Optimization

Module 7: Testing and Debugging

• Unit Testing with JUnit
• UI Testing with Espresso
• Debugging with Android Studio
• Best Practices for Testing Android Apps

Module 8: Deployment and Publishing 

• Preparing for Release: Signing and Packaging
• Publishing to Google Play Store
• App Store Optimization (ASO) and Analytics
• Managing App Updates and User Feedback

Capstone Project: Full Android App 

• Develop a complete Android application using Kotlin, demonstrating UI design, data handling, and API integration.

2. Native iOS Development (Swift)

Course Duration: 6 months

Module 1: Introduction to iOS and Swift Basics 

• Overview of iOS Development and Swift
• Setting up Xcode and iOS Simulator
• Basic Swift Syntax: Variables, Constants, and Control Flow
• Functions, Classes, and Structs

Module 2: SwiftUI and UIKit Basics 

• Introduction to SwiftUI and UIKit
• Views, Modifiers, and Layouts in SwiftUI
• Building UIKit Components: Buttons, Labels, and TableViews
• Responsive Design for Different Screen Sizes

Module 3: Navigation and User Interaction

• Navigation Stack and Tab Views in SwiftUI
• Working with Navigation Controllers in UIKit
• User Input: Forms and Gesture Recognition
• Data Passing between Views

Module 4: Data Storage and Persistence 

• Working with UserDefaults for Simple Data Storage
• Core Data for Local Data Storage
• Building a Data Model and Fetching Data
• Persisting and Retrieving Data Efficiently

Module 5: Networking and APIs

• Making API Calls with URLSession
• Parsing JSON Data in Swift
• Integrating RESTful APIs with SwiftUI/UIKit
• Offline Caching with Core Data

Module 6: Advanced iOS Development 

• Working with Combine Framework for Reactive Programming
• Dependency Management with Swift Package Manager
• Implementing Background Tasks and Notifications
• Integrating Device Features like Camera, GPS, and Sensors

Module 7: Testing and Debugging

• Unit Testing with XCTest
• UI Testing in Xcode
• Debugging Techniques in Xcode
• Best Practices for iOS Testing

Module 8: Deployment and Publishing 

• App Distribution with TestFlight
• Preparing for App Store Submission
• App Store Optimization (ASO) and Marketing
• Managing App Versions and User Feedback

Capstone Project: Full iOS App 

• Develop a complete iOS app with Swift and SwiftUI/UIKit, covering essential iOS development skills and best practices.

3. Hybrid Mobile Development (Flutter or React Native)

Course Duration: 6 months

Module 1: Introduction to Hybrid Development 

• Overview of Cross-Platform Development
• Choosing between Flutter and React Native
• Setting up Development Environment for Flutter and React Native
• Basics of Dart (for Flutter) and JavaScript/TypeScript (for React Native)

Module 2: UI Basics and Component Building 

• Flutter Widgets and React Native Components
• Basic Layouts and UI Structure
• Styling and Theming for Cross-Platform Consistency
• Introduction to Animation in Flutter and React Native

Module 3: Navigation and State Management 

• Navigation in Flutter (Navigator 2.0) and React Navigation
• State Management: Provider/Bloc in Flutter and Redux/Context API in React Native
• Passing Data between Screens
• Handling User Input and Forms

Module 4: Networking and APIs 

• Making API Calls with HTTP (Flutter) and Axios (React Native)
• JSON Parsing in Dart (Flutter) and JavaScript (React Native)
• RESTful API Integration and Offline Caching

Module 5: Data Storage and Persistence 

• Local Storage with SharedPreferences (Flutter) and AsyncStorage (React Native)
• Database Integration with Hive/SQFlite (Flutter) or Realm/SQLite (React Native)
• Data Handling Best Practices

Module 6: Advanced Features and Plugins 

• Using Native Device Features: Camera, GPS, and Sensors
• Integrating Custom Plugins and Native Modules
• Platform-Specific UI Customization (e.g., iOS and Android)

Module 7: Testing and Debugging 

• Unit and Widget Testing in Flutter
• Jest and Detox for React Native Testing
• Debugging Techniques and Best Practices for Cross-Platform Development

Module 8: Deployment and Publishing

• Preparing Apps for Google Play and App Store
• Code Signing and App Distribution
• Handling Platform-Specific Deployment Requirements
• Managing Updates and User Feedback

Capstone Project: Cross-Platform App 

• Develop a complete cross-platform app using Flutter or React Native, showcasing skills in UI, data management, and device integration.

• Duration: 8 months (6 hours per week) for any one of the three pathways you choose.
• Schedule: 2 classes per week, scheduled with you.
• Cost: ₦ 576,000 ₦ 349,500 (Three hundred and forty-nine thousand, five hundred Naira only) for any one of the three pathways you choose.

To become a hotcake software developer, these are the recommended stack:

• Frontend: React + TypeScript, Styled Components/TailwindCSS
• Backend: Node.js + TypeScript or Python with Django/FastAPI
• Database: PostgreSQL + MongoDB
• Authentication: Auth0 or Firebase Authentication
• API Layer: GraphQL + REST Hybrid
• Cloud & DevOps: Docker + Kubernetes + AWS/Azure
• CI/CD: GitHub Actions or GitLab CI

While one person can learn and work across the entire stack, it is often more effective to specialize in one or two areas to ensure a deeper understanding and skill mastery. Balancing specialization with a general knowledge of other areas can lead to a well-rounded and fulfilling career in software development.

For more personalized clarity session, send an email to info@ypco.com.ng or call/WhatsApp +234 702 630 7268. For quicker response, you may use the Live support Chatbox on this page.