DEV Community: codewitgabi

My H0 Hackathon journey: H0: Hack the Zero Stack with Vercel v0 and AWS Databases

codewitgabi — Wed, 24 Jun 2026 13:15:21 +0000

The H0 hackathon happens to be the second hackathon I would be participating in and it's been an exciting one and that's why I decided to share my experience here in detail from the innovation stage up to the product stage.

The entire goal of this hackathon is to build any fullstack application using any one of AWS databases (Amazon Aurora PostgreSQL, Aurora DSQL, or DynamoDB) and Vercel's V0 or deploying your app on vercel and my team and I used the opportunity to build an application targeted towards students to help solve a problem we also face as students.

Problem statement

Many students are either too shy or haven't really participated in public speaking and there comes a stage usually in the final year when they have to defend project, present thesis or even handle oral examinations. Confidence and clarity during these presentations actually count for a lot and because of lack of preparation before they are faced with reality, they tend to score poorly.

Solution

With the afore mentioned problem, we came up with a solution that creates a simulation environment for students to actually practice different scenarios with AI powered panelists that give them an experience close to what they will be facing in reality. This solution is what brought about Simustratum

System design

After brain storming on the idea and we were set to go, the next step was to take a deep dive into the technologies we were using and why we were using them and this was affected by the tools we have worked with in the past and were comfortable working with.

Tech stack

Nextjs (frontend)
Fastapi (Backend)
Aurora Postgresql (Database)
AWS EC2 (Backend hosting)
Nginx (Reverse proxy)
Duck DNS (Server Domain name)
Git (Version control)
Cloudinary (Blob storage)
Github Actions (CI/CD pipeline)
Anthropic API (Fallback LLM)
Google Gemini (Default LLM)
Qdrant Cloud (RAG)

Why use Aurora Postgresql over Aurora DSQL and Dynamodb?

Relational data model fits perfectly. Simustratum has deeply connected data — users own sessions, sessions have transcript turns, turns reference specific panelists, scores update per turn. That's a join-heavy, foreign-key-enforced relational structure. Aurora PostgreSQL handles this natively. DynamoDB would have required redesigning the entire data model around key-value access patterns. Read more here
JSONB for panelist configs. The Session.panelists column stores flexible panelist data (name, role, strict, inquisitive, id) as a JSONB blob — queryable, indexable, and schema-flexible without a separate table. This is a PostgreSQL-native feature. DynamoDB also stores JSON but without SQL operators to query inside it, and Aurora DSQL has more limited JSONB support than standard Aurora PostgreSQL. AWS migration playbook
ACID transactions protect transcript integrity. Every session turn requires writing a TranscriptTurn row AND updating the parent Session scores atomically — either both commit or neither does. Aurora PostgreSQL's full ACID guarantees mean your turn sequence is always consistent and replay always gets a gapless ordered record. DynamoDB's transactions are limited to 100 unique items per write. DynamoDB's Contraint DynamoDB's Transactions
The feedback report needs analytical SQL. Features like "show my clarity score trend across all my defense sessions" or "which panelist asked the most follow-up questions" are window functions and multi-table aggregations. In Aurora PostgreSQL that's a single SQL query. In DynamoDB it would require exporting data to Athena or Redshift — real additional infrastructure. Aurora DSQL would handle the queries but is overkill for a single-region app and is too new to have the production track record Aurora PostgreSQL has.
It would be easier for developers to contribute to by quickly spinning up their local postgresql server; Aurora has full postgresql support

Problems we encountered

I would say development was quite smooth, most of the issues we faced while building happened when we decided to go live (Still not fully resolved yet); having to work with AWS services for the first time; setting up EC2 instance for the backend and running nginx. The major issue I would say was setting up the Aurora postgresql server on AWS - Took us about 4 tries to do cause we weren't sure we were setting up the right db but we were all along.

What's next?

Next step will be wrapping up our submission and see how it goes from there. Here is the live url for those who want to try Simustratum out

Introduction to system design

codewitgabi — Fri, 15 Aug 2025 19:10:52 +0000

What is system design?

System design is the process of defining the elements of a system, as well as their interactions and relationships, in order to satisfy a set of specified requirements.

It involves taking a problem statement, breaking it down into smaller components and designing each component to work together effectively to achieve the overall goal of the system.

What does this mean? System design is that planning stage in software engineering where you design the flow, patterns, architecture of how the system you're trying to build becomes functional and efficient, taking better steps to build a better system. So you're asked to build an authentication system and yeah, you probably already know how to build one but those that actually satisfy the requirement of the project? This is the very big question to ask as a software engineer designing a system. It starts from as little as the language, framework to use.

How do I approach system design?

This is a very important question and I'll be going through a few steps as to how you can approach it and build a better system

Understand the problem:
This is the most important stage of all. Most software engineers jump right into building a solution without actually understanding the problem it is trying to solve and also the use case. You want to make sure you understand the problem brought before you down to the last detail before you start proffering solutions especially during interviews as this is one of the stages of the interview process and a determining one at that. Be sure to ask a lot of questions to understand what problem you're going to be solving and then you can start bringing in those solutions.
Identify the scope of the system:
This still falls under understanding the problem. You should try and get the scope of the system in the sense that building an authentication system for a blog application is different from building one for a fintech application. A blog application does not necessarily need 2FA (Two-factor authentication) but a fintech definitely does. But now, there are some blog applications that may require one and that is why you need to identify and understand the scope of the system you're trying to build.
Create a high-level design:
A diagram is necessary if this is going to be a long term project and not just an interview process as this will help future engineers to understand the system and how it works. As you keep improving the system, be sure to improve the design. If necessary, version it for high end maintainability.
Continuously monitor and improve the system:
Now, you don't want to just build a system and assume everything is perfect. I don't think there will ever exist a perfect system so you would want to monitor it and see ways it can be improved. This should be done from continuously.

This is just an introduction to my series on system design. I will be dropping some system design concepts in the next one.

Get windows 11 activation key and activate windows

codewitgabi — Mon, 19 Aug 2024 18:29:58 +0000

Do you currently face the issue where your windows activation key is expired and then you need to activate it? Tired of that regular popup asking you to activate your windows? Let me show you how to do that in less than 2 minutes.

Open the command prompt

Open the command prompt on your desktop by typing cmd on the search bar. Open it in Run as Administrator.

You should have something that.

You should have a black screen popup. In there, just type the below command or copy and paste it.

wmic path SoftwareLicensingService get OA3xOriginalProductKey
OA3xOriginalProductKey

Once that's done, your activation code will be printed right there on the command prompt.

Next step

The next thing to do is to go to settings and activate your windows. Click on your search bar and type settings.

Click on Activation and Change product key. Enter your generated activation key there and click next.

Boom!!! That's all you need to do to activate your windows. Don't forget to leave a thumbs up and a comment if it worked for you.

fastapi opensource project

codewitgabi — Sat, 03 Aug 2024 17:48:06 +0000

Hello world!! It's been a while.

I have been so engrossed with my intership at hng and it has been a wonderful experience, learning a lot of standard conventions to use while coding, best practices to follow when creating commits and pull requests etc.

One of my most amazing experiences was when most of the interns were asked to switch stack. I was on the backend track and already familiar with django and express but django wasn't among the required stack for the project we were working on. The preferred stack was fastapi. We had to learn fastapi in two to three days. It was cool since most of us were already used to the pressure of learning tools at such short timeframe.

Learning fastapi was one thing but then I always ask myself - how good will I be with this new framework? There is a quick and easy was to learn a tool and master it quickly and that's by building projects. With that in mind, I decided to start a fastapi open source project that covers most backend concepts and majority of what could be found in the official documentation

With this project, contributors will be able to

Understand the workflow of fastapi
Understand how to make queries
Write unittests using pytest
Write efficient PRs and issues

Here is the link to the project https://github.com/codewitgabi/full-featured-social-media-application-fastapi. A star wouldn't be too much to ask from you and more than that, I would love to have you as a contributor so 'we' can learn a few coding tricks from you.

Database design for backend engineers

codewitgabi — Sat, 27 Jul 2024 00:52:40 +0000

Often times, as backend engineers, we jump into writing our database schemas/models without properly planning what they will look like and this leads to more and more migration files been generated.

For some of us, we stick to using pen and paper which is quite cool but then we may have no reference to them in the future or how then do we share those designs with future backend engineers who will work on the project (...cause you may not be working on that project forever.)

Allow me to introduce DBML to you; DBML (Database Markup Language) is an open-source DSL language designed to define and document database schemas and structures. It is designed to be simple, consistent and highly-readable.

It also comes with command-line tool and open-source module to help you convert between DBML and SQL. - dbml

What does dbml look like?

On the left, we have the dbml syntax and be the right, we have the db diagram.

With this, you can share with your team members and also have reference for future developers to quickly know what's really going on in the database aspect of your application.

DBML is quite easy to learn. No need for long tutorials. All you need is the doc and you're set to write those beautiful database designs.

Why should I use dbml?

For collaboration with team members
Nice looking design to quickly comprehend relationship between tables, db columns, etc
Backend developers often find it difficult showcasing their skills to employers....this should serve as something to have in your portfolio
You could easily convert these into sql syntaxes

I hope you enjoyed this tutorial? If so, leave a reaction else leave a comment in the comment section. Thanks for reading.

Database migrations inconsistency in django

codewitgabi — Fri, 28 Jun 2024 19:07:09 +0000

Working with django can be really cool until you bumb into migrations inconsistency.

Migrations inconsistency happens when there is a rapid change in your models. Say, field altering, or change of table name. A quick fix is to probably delete the migration files, re-makemigrations and then migrate which may or may not work. Another try is to delete the database which would be tempting to do but then what if you are working on a production database. Of course, that's not a very nice approach to take.

This leads us to database backup. So, you have thought of everything but it seems deleting the database might be the best approach? No problem, all you need to do is backup the database and then as soon as a new one is created, you quickly inject the data back into the database.

Database backup with django

Django is a robust framework with batteries (lots of it), making it easier to perform database operations with its Object-Relational Mapper. Database backup is not an exemption. To backup your database, run the following commands.

python3 manage.py dumpdata > db-backup.json

Where db-backup.json is the name of the file that will contain your database data.

Reloading the database

To load the data back into the database, run the command below

python3 manage.py loaddata db-backup.json

And voila, you now have your "untampered" database

Just a brief info. Interships are a nice way to get your hands "dirty". hng is one place to get started for free and also hng-premium for a rich-full internship with lots of opportunities.

Messaging queues (Rabbitmq as broker)

codewitgabi — Sun, 16 Jun 2024 14:10:34 +0000

Since backend development goes beyond building CRUD applications, I am here to discuss one of the core concepts of backend development which is message queueing.

In DSA, queues are basically a structure that follow the FIFO (First In First Out) rule; meaning that the first element to be entered is the first to be processed just like queue in banks, shoprite etc.

A message queue is a form of asynchronous service-to-service communication used in serverless and microservices architectures. Messages are stored on the queue until they are processed and deleted. Each message is processed only once, by a single consumer AWS.

Today, I will discuss some things that need to be considered to have a kind of reliable server when using Rabbitmq as a message broker.

Message acknowledgement: Doing a task can take a few seconds, you may wonder what happens if a consumer starts a long task and it terminates before it completes. Basically, once our producer delivers a message to the consumer, it marks it for deletion. In this case, if you terminate a worker, the message it was just processing is lost. The messages that were dispatched to this particular worker but were not yet handled are also lost. If a worker dies, we'd like the task to be delivered to another worker. In order to prevent this from happening, Rabbitmq provides message acknowledgement. If a consumer dies (its channel is closed, connection is closed, or TCP connection is lost) without sending an ack, RabbitMQ will understand that a message wasn't processed fully and will re-queue it. If there are other consumers online at the same time, it will then quickly redeliver it to another consumer. That way you can be sure that no message is lost, even if the workers occasionally die.

To achieve this, do this

def callback(ch, method, properties, body):
    # your code
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(queue='hello', on_message_callback=callback)

Message durability: We have learnt how to handle tasks when a worker is stopped. How do we handle them if our broker is stopped? When RabbitMQ quits or crashes it will forget the queues and messages unless you tell it not to. Two things are required to make sure that messages aren't lost: we need to mark both the queue and messages as durable. This should be done both for the producer and consumer (or worker).

channel.queue_declare(queue='queue_name', durable=True)

If you have already created a queue that's not durable, updating it won't change that so it's better to do that at the beginning

At that point we're sure that the task_queue queue won't be lost even if RabbitMQ restarts. Now we need to mark our messages as persistent - by supplying a delivery_mode property with the value of pika.DeliveryMode.Persistent

channel.basic_publish(
    exchange="",
    routing_key="queue_name",
    body=message,
    properties=pika.BasicProperties(delivery_mode=pika.DeliveryMode.Persistent),
)

Fair dispatch: By default, if we have multiple workers/consumers running, rabbitmq tries to share tasks to these workers evenly using the round-robin algorithm (RRA) but what if one worker is already done processing its task and the others are not done but because of RRA, it's not its turn so it becomes idle and the request is added to another worker that is processing a task. To fix this issue, you should use a fair dispatch in the worker.

channel.basic_qos(prefetch_count=1)

What is a stack?

codewitgabi — Sat, 15 Jun 2024 18:05:45 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

Just like when you have crate of eggs or drinks placed one on top the other, you can't remove the one at the bottom else, you tend to scatter the whole arrangement. So you start with the one at the top (the last added crate) and then go all the way down.

What is a Queue?

codewitgabi — Sat, 15 Jun 2024 17:58:07 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

When you visit a bank or you go to the supermarket to get some groceries, you stay in line. The person in front of you gets answered first because he was there before you. That's basically a queue in computer science

What is memoization

codewitgabi — Thu, 13 Jun 2024 09:04:40 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

Say I go to a store to get some groceries, the price of my items is calculated but then I decide to add a new item, the new price is added to the already calculated price instead of adding the price of every item again. That is memoization

How to efficiently use drf_social_oauth2 and django_rest_framework_simplejwt

codewitgabi — Thu, 13 Jun 2024 01:43:40 +0000

Hey guys!!

So I was working on a rest api application with django and django rest framework but then I happened to run into a lot of issues using drf_social_oauth2 and django_rest_framework_simplejwt. The issue was that the former strictly uses Bearer authentication header while the latter uses any authorization header of your choice so what I did initially was to use JWT for simplejwt. This worked fine even though on the client side, my team and I had to write some logic to know if the user initially logged in via oauth or regular auth. This was okay but I was not too comfortable with it. I later thought of a solution to fix the issue and today, I will be showing you what I did to fix this boring issue.

# settings.py
# before

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": (
        "rest_framework_simplejwt.authentication.JWTAuthentication",
        "oauth2_provider.contrib.rest_framework.OAuth2Authentication",
        "drf_social_oauth2.authentication.SocialAuthentication",
    ),
}

# settings
# after

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": (
        "rest_framework_simplejwt.authentication.JWTAuthentication",
    ),
}

So from the two code in our settings.py, you can see we had to remove the oauth2_provider and simplejwt authentication from the authentication classes and that's because we will no longer be using it to authenticate. We will default back to using simplejwt and that brings us to the next part.

# views.py

# builtin imports
from json import loads as json_loads
from datetime import datetime

from oauth2_provider.settings import oauth2_settings
from oauth2_provider.views.mixins import OAuthLibMixin
from oauthlib.oauth2.rfc6749.errors import (
    InvalidClientError,
    UnsupportedGrantTypeError,
    AccessDeniedError,
    MissingClientIdError,
    InvalidRequestError,
)

from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
from django.contrib.auth import get_user_model

# third party imports
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.permissions import AllowAny
from rest_framework_simplejwt.tokens import RefreshToken, AccessToken
from rest_framework.status import HTTP_400_BAD_REQUEST
from rest_framework.request import Request

from drf_social_oauth2.serializers import ConvertTokenSerializer
from drf_social_oauth2.oauth2_backends import KeepRequestCore
from drf_social_oauth2.oauth2_endpoints import SocialTokenServer


# user object
User = get_user_model()


class CsrfExemptMixin:
    """
    Exempts the view from CSRF requirements.
    NOTE:
        This should be the left-most mixin of a view.
    """

    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(CsrfExemptMixin, self).dispatch(*args, **kwargs)


class ConvertTokenView(CsrfExemptMixin, OAuthLibMixin, APIView):
    """
    Implements an endpoint to convert a provider token to an access token

    The endpoint is used in the following flows:

    * Authorization code
    * Client credentials
    """

    server_class = SocialTokenServer
    validator_class = oauth2_settings.OAUTH2_VALIDATOR_CLASS
    oauthlib_backend_class = KeepRequestCore
    permission_classes = (AllowAny,)

    def post(self, request: Request, *args, **kwargs):
        serializer = ConvertTokenSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        # Use the rest framework `.data` to fake the post body of the django request.
        request._request.POST = request._request.POST.copy()
        for key, value in serializer.validated_data.items():
            request._request.POST[key] = value

        try:
            url, headers, body, status = self.create_token_response(request._request)
        except InvalidClientError:
            return Response(
                data={"invalid_client": "Missing client type."},
                status=HTTP_400_BAD_REQUEST,
            )
        except MissingClientIdError as ex:
            return Response(
                data={"invalid_request": ex.description},
                status=HTTP_400_BAD_REQUEST,
            )
        except InvalidRequestError as ex:
            return Response(
                data={"invalid_request": ex.description},
                status=HTTP_400_BAD_REQUEST,
            )
        except UnsupportedGrantTypeError:
            return Response(
                data={"unsupported_grant_type": "Missing grant type."},
                status=HTTP_400_BAD_REQUEST,
            )
        except AccessDeniedError:
            return Response(
                {"access_denied": f"The token you provided is invalid or expired."},
                status=HTTP_400_BAD_REQUEST,
            )

        body = json_loads(body)

        if "error" in body:
            return Response(data=body, status=status)

        token = body.get("access_token")
        user = User.objects.filter(oauth2_provider_accesstoken__token=token)[0]

        refresh = RefreshToken.for_user(user)
        access_token = str(refresh.access_token)
        decoded_token = AccessToken(access_token)
        expiration_time = datetime.fromtimestamp(decoded_token["exp"])

        return Response(
            {
                "id": user.id,
                "first_name": user.first_name,
                "last_name": user.last_name,
                "middle_name": user.middle_name,
                "fullname": f"{user.first_name} {user.last_name}",
                "email": user.email,
                "phone": user.phone.as_e164,
                "profile_picture": (user.profile_pic.url if user.profile_pic else None),
                "refresh": str(refresh),
                "access": access_token,
                "expiry": expiration_time,
            },
            status=status,
        )

It's a lot but for now, just ctrl + c and ctrl + v. The code is from the official drf_social_oauth codebase, I'm just overriding it.

token = body.get("access_token") gets the access_token from the body after the social auth access token has been converted.
user = User.objects.filter(oauth2_provider_accesstoken__token=token)[0] gets the user that is associated with the token.

refresh = RefreshToken.for_user(user)
access_token = str(refresh.access_token)
decoded_token = AccessToken(access_token)
expiration_time = datetime.fromtimestamp(decoded_token["exp"])

Here is where we change things.
First, we create a simplejwt refresh token for the user. Then we get the access token and expiration_time of the token. This is the token that will be used by the user to authenticate views.

With this, everything is done. You can now authenticate using Bearer in the authentication header.

Django Query Expressions F()

codewitgabi — Thu, 21 Dec 2023 01:44:25 +0000

Creating queries in django can go from simple to complex. Queries can be calculated in two places;

Python side and
Database side.

Writing queries from the python side always seem like the easiest thing to do but in reality, it reduces the performance of our application. So if the performance of your application means anything to you, you should read this article to the end without missing a thing as it will help you write django queries like a pro.

Query expressions describe a value or a computation that can be used as part of an update, create, filter, order by, annotation, or aggregate. When an expression outputs a boolean value, it may be used directly in filters. There are a number of built-in expressions (documented below) that can be used to help you write queries. Expressions can be combined, or in some cases nested, to form more complex computations.

Django supports negation, addition, subtraction, multiplication, division, modulo arithmetic, and the power operator on query expressions, using Python constants, variables, and even other expressions.

Going forward, I assume you're already familiar with the basics of django.

# app. models

class Company(models.Model):
    name = models.CharField(max_length=300)
    num_employees = models.IntegerField(default=0)
    num_chairs = models.IntegerField(default=0)
    is_registered = models.BooleanField(default=False)

    class Meta:
        verbose_name_plural = "Companies"
        db_table = "Company"
        indexes = [
            models.Index(fields=["name", "is_registered"])
        ]
        constraints = [
            models.CheckConstraint(check=models.Q(num_employees__gte=0), name="num_employees_gte_0"),
            models.CheckConstraint(check=models.Q(num_chairs__gte=0), name="num_chairs_gte_0")
        ]

    def __str__(self) -> str:
        return self.name


class Product(models.Model):
    class Meta:
        db_table = "Product"
        indexes = [
            models.Index(fields=["name", "price", "company"])
        ]
        constraints = [
            models.CheckConstraint(check=models.Q(price__gte=0), name="price_gte_0")
        ]

    name = models.CharField(max_length=100)
    company = models.ForeignKey(Company, on_delete=models.CASCADE)
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self) -> str:
        return self.name

The F() query expression is used to query objects based on a model's field or its ForeignKey. It can be used to update model objects, filter queries if it returns a boolean value, etc. It makes it possible to refer to model field values and perform database operations using them without actually having to pull them out of the database into Python memory.

F() therefore can offer performance advantages by:

getting the database, rather than Python, to do work
reducing the number of queries some operations require

Some examples

# Find companies that have more employees than chairs.
Company.objects.filter(num_employees__gt=F("num_chairs"))

In the above event, the Company was filtered based on its field(num_chairs).

companies = Company.objects.filter(num_employees__lt=F("num_chairs")).annotate(workers_needed=F("num_chairs") - F("num_employees"))

The above query filters the Company object to those whose employees are less than the chairs they have in which case they want to get the number of seats to be filled. If this were to be done without the F() expression, that'd be a lot of computations.

Say the company wants to increase the prices for all its products. An easy way to do that will be;

Product.objects.update(price= F("price") + 150)

Which is better than

for product in Product.objects.all():
    product. price += 150
    product. save()

Updating a single object

product = Product.objects.first()
product.price = F("price") + 150
product.save()

F() assignments persist after Model.save()

F() objects assigned to model fields persist after saving the model instance and will be applied on each save(). For example:

product = Product.objects.first()
product.price = F("price") + 150
product. save()

product.name = "New name"
product.save()

The product's price will be updated twice in this case. If it’s initially 50, the final value will be 450. This persistence can be avoided by reloading the model object after saving it, for example, by using refresh_from_db().

product = Product.objects.first()
product.price = F("price") + 150
product. save()
product.refresh_from_db()

product.name = "New name"
product.save()

Using F() with logical operations

This happens to be my favorite part as it allows you to toggle boolean values.

company = Company.objects.first()
company.is_registered = ~F("is_registered")
company.save()
company. refresh_from_db()

If the value of is_registered is True, it changes it to False and vice versa.

That would be all for this part, see you on the next.