DEV Community: Boniface Kimani Muguro

Building Ticksy – A Modern Event Ticketing Platform

Boniface Kimani Muguro — Fri, 01 Aug 2025 23:17:09 +0000

Introduction
In Phase 5 of the software engineering program, I challenged myself and my team to build Ticksy, a full-stack event ticketing and management platform designed to make attending and organizing events easier, faster, and more accessible—especially in regions with local payment needs like MPESA.

This phase was all about applying everything we’ve learned: from backend modeling and validation to frontend routing and global state management. We also explored technologies outside the core curriculum to take our application to the next level.

Technologies Used
Layer Tech Stack
Frontend ReactJS, Redux Toolkit, Axios
Backend Flask, SQLAlchemy, Marshmallow
Database PostgreSQL
Auth JWT with Flask-JWT-Extended
Payment MPESA STK Push API
Design Figma (Mobile-first design)

What I Implemented in Phase 5
Here’s a breakdown of the key features and requirements I addressed during this phase:

1. Flask & SQLAlchemy Backend
The backend was built using Flask, with SQLAlchemy ORM to define models and manage database interactions. I used Marshmallow for serialization and request validation.

2. Many-to-Many Relationships
A key part of the database involved many-to-many relationships, such as:

Users ↔ Events through TicketOrders

Users ↔ Roles (e.g., Admin, Organizer, Attendee)
This allowed flexible access control and event participation tracking.

3. Four or More Models
We implemented several models, including:

User
Event
Ticket
TicketOrder

Review
All models were fully integrated and managed through RESTful endpoints.

4. React Router with 5+ Routes
The frontend uses React Router v6, with clean, role-based navigation:

/login – User Authentication

/events – Upcoming Events Listing

/events/:id – Single Event Details

/dashboard – Organizer/Admin Dashboard

/tickets – My Tickets Page

/admin – Admin-only management panel

5. CRUD Functionality (RESTful)
Full CRUD was implemented for the Event model:

Create: Organizers can create new events.

Read: All users can view events.

Update: Organizers can update their events.

Delete: Organizers can delete events.

CRUD actions followed REST conventions and returned appropriate status codes and messages.

6. Validations and Error Handling
Both the backend and frontend handled validations gracefully:

Schema validation via Marshmallow

Custom error messages for duplicate users, missing fields, bad logins, etc.

User-friendly error alerts in the UI using React Toasts

7. Something New: MPESA STK Push
We explored something not taught in the curriculum: mobile money payments. I integrated MPESA STK Push API to allow users in Kenya to check out securely using mobile money, a feature rarely seen in typical bootcamp projects.

** 8. Global State with Redux Toolkit**
Instead of useContext, we adopted Redux Toolkit for global state:

authSlice: Manages login/signup and role-based UI.

eventsSlice: Handles event fetching, creation, update, and deletion.

ticketsSlice: Manages user ticket history and new orders.

This helped us keep the codebase modular, clean, and scalable.

Lessons Learned
Planning is everything. Starting with a Figma design helped us avoid confusion during component development.

Redux Toolkit simplified global state logic compared to useContext + prop drilling.

Error handling on both frontend and backend is crucial for good UX.

Implementing MPESA payments taught me how to integrate real-world APIs and handle async callbacks.

Working as a team pushed me to use GitHub branches, pull requests, and resolve merge conflicts effectively.

** Future Improvements**
Add Google login for quicker sign-up.

Implement QR-code check-in for event access control.

Push real-time updates using WebSockets.

Make Ticksy a PWA for offline support.

** Final Thought**
Phase 5 was the most challenging but rewarding phase yet. I now feel confident building scalable full-stack applications with modern tools and APIs. The real-world use case of Ticksy has made me more excited to explore the world of software engineering—especially where it intersects with payment systems, event management, and user experience design.

"Build something real. Break things. Fix them. That’s how we grow." – My Phase 5 mantra.

My Journey Through Flask and Full-Stack Development

Boniface Kimani Muguro — Tue, 01 Jul 2025 07:44:44 +0000

Over the past three weeks, I’ve immersed myself in backend development with Flask, explored RESTful API design, and integrated React for full-stack applications. Here’s a breakdown of my learning journey, key takeaways, and how these skills translate to real-world development.

Week 1: Flask Foundations
Day 1: Flask Fundamentals
Core Concepts: WSGI, routing, request-response cycle.

Hands-on: Built basic Flask apps, handled HTTP methods, and validated fundamentals via quizzes.

Key Insight: Understanding how Flask abstracts low-level web protocols streamlined my backend workflow.

Day 2: Flask-SQLAlchemy & Databases
Database Integration: ORM setup, CRUD operations, migrations with Alembic, and database seeding.

Serialization: Converted SQLAlchemy models to JSON for API responses.

Project Highlight: Built a bookstore app with dynamic querying and RESTful endpoints.

Day 3: Modeling Relationships
Advanced ORM: Implemented one-to-many and many-to-many relationships (e.g., authors ↔ books).

Relationship Serialization: Nested related data in API responses using serialization patterns.

Day 4: Consuming APIs
HTTP Clients: Used requests to fetch data from external APIs (e.g., weather data, GitHub).

Tooling: Tested endpoints with Postman and handled pagination/rate limiting.

Day 5: Building APIs
RESTful Design: Created GET/POST/PATCH/DELETE endpoints for resource management.

Lab: Built a "Chatterbox" messaging API with error handling and validation.

Week 2: Advanced Backend & Full-Stack
Day 6: REST APIs with Flask-RESTful
Structured Endpoints: Leveraged Flask-RESTful for clean resource-based routing.

HATEOAS: Explored hypermedia-driven responses using Marshmallow.

Day 7: Data Validation
Constraints: Database-level validations (e.g., unique, nullable).

Application Logic: Added custom validations (e.g., email format, password strength).

Day 8: Full-Stack Integration
React + Flask: Served React apps from Flask routes and managed API proxying.

Form Handling: Implemented form validation with Formik.

Day 9: Authentication
IAM Workflow: Cookie/session management, password hashing with bcrypt, and route protection.

Lab: Built a user auth system with login/logout and role-based access control.

Day 10: Deployment
CI/CD: Deployed Flask APIs and React apps to Render.

Database Hosting: Configured PostgreSQL on Render and managed environment variables.

Key Projects & Challenges
Phase 4 Code Challenges:

Superheroes API: Modeled hero-team relationships with CRUD operations.

Pizza Restaurants: Many-to-many relationships (restaurants ↔ pizzas).

Late Show: Full-stack deployment with React frontend and Flask backend.

Mock Challenges: Solved problems like "Camping Fun" (gear rental API) and "Cosmic Travel" (interstellar booking system).

Capstone Project: A full-stack application with auth, database relationships, and RESTful endpoints (https://github.com/Chenzie2/Coursify-Frontend).

Lessons Learned
Start Simple: Flask’s minimalism makes it perfect for rapid prototyping.

ORM Power: SQLAlchemy abstracts complex SQL while maintaining flexibility.

Decouple Frontend/Backend: Serve React independently for scalability.

Security First: Always hash passwords and validate incoming data.

Deployment ≠ Afterthought: Configure production settings (CORS, env vars) early.

What’s Next?
Explore Flask asynchronous support for high-I/O apps.

Dive deeper into containerization (Docker) and load balancing.

Experiment with GraphQL as an alternative to REST.

This phase transformed how I approach backend systems. Flask’s "micro" framework forced me to understand each layer of the stack—no magic, just deliberate design.

Flask #Python #RESTAPI #SQLAlchemy #React #WebDev #Backend #FullStack

Bridging Code and Data: Exploring Python and SQLAlchemy ORM

Boniface Kimani Muguro — Thu, 29 May 2025 04:38:41 +0000

Navigating the Next Phase: Building Smarter Applications with Python, SQL, and SQLAlchemy
As the tech industry continues to prioritize scalability, maintainability, and data integrity, the bridge between object-oriented programming (OOP) and relational databases has never been more vital. Phase 3 of this curriculum explores that bridge—Object-Relational Mapping (ORM)—while also cementing the Python fundamentals that make scalable applications possible.

The Shift Toward Abstraction: Why ORM Matters
Modern applications are increasingly data-driven. Developers need to translate complex real-world relationships into a structure that a computer—and more specifically, a relational database—can interpret. ORMs like SQLAlchemy streamline this process by allowing developers to manipulate database records using Python classes and objects, eliminating the constant back-and-forth with raw SQL queries.

ORMs don’t just improve productivity; they promote cleaner, more maintainable code and reduce the risk of SQL injection vulnerabilities. In a world where rapid development cycles are the norm, these abstractions have become indispensable.

Best Practices from the Backend Trenches
Through hands-on labs and projects, Phase 3 drives home several best practices in Python and ORM design:

Keep It DRY:
Whether you're defining class attributes or writing query methods, repeating yourself is a red flag. Use inheritance and utility functions to encapsulate reusable logic.
Validate Early, Fail Fast:
ORM validation methods ensure data consistency before it hits your database. Python properties and decorators allow you to enforce rules at the model level.
Readability Is Power:
From proper use of Python’s indentation and control flow to meaningful variable names in your classes, readable code isn’t just a luxury—it’s a professional necessity.
Understand the SQL Under the Hood:
SQLAlchemy may abstract SQL, but knowing what's happening behind the curtain is essential. Use SQLAlchemy’s echo mode to inspect the generated queries and optimize them when needed.

Data Structures, Algorithms, and Real-World Relevance
Phase 3 also introduces fundamental data structures and algorithms. These aren't just academic concepts—they’re the backbone of application performance. Choosing a set vs. a list, or knowing when to implement a doubly linked list over a stack, can mean the difference between an app that scales and one that struggles.

What Comes Next: AI and APIs
As we head into API development and AI integrations (like the OpenAI API), the need for efficient, reliable backend logic becomes even more critical. Clean Python, thoughtful ORM design, and optimized SQL queries aren't just classroom exercises—they’re the foundation for real-world innovation.

Passionate software developer!

Boniface Kimani Muguro — Wed, 23 Apr 2025 17:21:02 +0000

Hello! I’m an aspiring software engineer studying at Moringa School. I’ve recently learned React, a JavaScript library that helps build user interfaces with reusable components and efficient updates as data changes. I’m also skilled in Tailwind CSS, which provides utility classes for quickly creating custom, responsive designs directly in my HTML. Additionally, I have a solid grasp of HTML for structuring web content, JavaScript for writing dynamic, event-driven code, and CSS for controlling the look and feel of a page, including layout, typography, and responsive styling. These tools together enable me to build modern, accessible, and maintainable web applications.