DEV Community: Mohamed Adel

Sassy Chef - local Gemma plans meals & shopping list so We stay lazy

Mohamed Adel — Fri, 23 Oct 2026 13:45:18 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

I built Sassy Chef as a tiny local meal planner that does the morning brainwork I keep skipping.

Every day the same loop: what do I cook, what am I missing from the fridge, do I need to go buy something. I usually lose that fight and order food. This week’s theme is literally “reward laziness,” so I made the thing that should have existed already:

One command in the morning
Local Gemma 3 (gemma3:4b via Ollama) plans breakfast → lunch → dinner
It looks at what’s already in my pantry JSON before inventing a shopping list
It dumps a markdown plan + a 1–2 page PDF I can print and take to the kitchen / store
Personality is a sassy chef that roasts my procrastination, not my life choices

The lazy trick I’m happiest about: the shopping list is assumed bought after plan. I don’t have to check boxes into a CLI every evening. If I actually skipped spinach, that’s the only day I type anything:

python -m sassy_chef missed spinach

That pulls it out of the pantry and parks it for tomorrow’s list. Normal days = zero extra work. That felt more “sloth” than a fancy UI.

Demo

Code

mohamedation / sassy-chef

Local AI that plans your day of cooking so you don't have to think before coffee.

Sassy Chef

Local AI that plans your day of cooking so you don't have to think before coffee.

Every morning it writes breakfast → shopping list → lunch → dinner, keeps a rolling pantry + shopping list on disk, and dumps everything as markdown you can paste into email, Google Keep, or Tasks.

Built for Hacktoberfest 2026 Week 3 — Slow and Steady: open-weight AI that rewards laziness. Runs entirely offline with Gemma 3 via Ollama (default gemma3:4b).

Why open / local

Your fridge and habits never leave your machine
No API bill for a daily habit
Swap models in one config line (gemma3:4b → gemma3:12b, etc.)
Works when the internet doesn't

Requirements

Python 3.11+
Ollama running locally
A pulled model (default Gemma):

ollama serve          # if not already running
ollama pull gemma3:4b

PDF day sheets need one package (fpdf2). The meal planner…

View on GitHub

ollama pull gemma3:4b
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt   # only fpdf2 for the PDF sheet
python -m sassy_chef doctor
python -m sassy_chef plan
# open output/today-day.pdf

Stack on purpose: Python stdlib + Ollama HTTP + optional fpdf2. No web app, no cloud key, no “agent framework” for a problem that is one JSON chat and a JSON file.

How I Built It

The loop

pantry.json + missed leftovers + recent meals
        → Ollama chat (gemma3:4b, format=json, sassy system prompt)
        → breakfast / lunch / dinner + shopping_to_buy_today
        → write cooking.md + shopping.md + day.pdf
        → assume list bought → pantry updated, shopping cleared
        → (only if needed) missed <item>

Gemma does the creative part: titles, steps, “what am I missing,” the roast. Python owns the boring part: files, PDF layout, “did you actually buy it or are we lying to tomorrow.”

Design choices that mattered

Optimistic shopping. First version had a bought command. That’s daily chores. Flipped it: assume success, missed only on failure. Fits the theme harder than another checkbox UI.
Printable PDF. Markdown is great for email/Keep. Standing in a kitchen I want one A4 page with checkboxes, not three files and a phone.
Pantry is a JSON file. Deliberately dumb. Easy to edit by hand when the model’s quantity guesses are wrong.
Sassy, not mean. Prompt rules: roast laziness, leave bodies/culture alone. The model still occasionally invents “Rice and Chicken (Almost)” when there’s no chicken, which is why the prompt now says: if it’s in the title, it has to be in pantry or on the shopping list.

Why Gemma / Ollama

I already run Ollama. gemma3:4b is small enough for a morning habit and good enough at structured JSON if you ask clearly and validate the three meal slots. Config is one line if I want gemma3:12b later. Same code path.

Why Does Open Innovation Matter?

Privacy. My fridge contents and “I skipped spinach again” habits are not a product telemetry event. They stay in data/pantry.json on disk.

Offline. Breakfast planning should not fail because the API is rate-limited. Laptop + Ollama is enough.

Cost. A daily meal plan against a paid API is a subscription I would cancel in week two. Local weights = free after the hardware I already own.

Swapability. Open weights mean I can change the model without rewriting the app or begging a vendor. That matters more for a habit tool than for a one-off demo.

Closed APIs are fine when you need the absolute best model and you’re okay shipping your life to someone else’s GPU. For “what do I cook from this sad pantry,” open + local won on privacy and “set it once.”

Prize Categories

Overall
Best Use of Gemma daily plans run through Gemma via Ollama (gemma3:4b default, model override in config.toml / --model)

Limits

Small models still hallucinate a missing ingredient into a meal title if you don’t constrain them
Pantry quantities are approximate (“4 eggs left”) so not a real inventory system with barcodes
PDF is English / Latin-friendly via DejaVu when available; other scripts may need a font tweak
No nutrition tracking, no fancy UI for this demo
Cron is on you; the tool doesn’t install a daemon

If you also open the fridge, stare for thirty seconds, and then order something, this might save you that stare.

[Boost]

Mohamed Adel — Wed, 14 Oct 2026 15:33:41 +0000

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission 💸

Mohamed Adel

Oct 14

Invoico - yet another invoice and receipts assistant

#hf26challenge #devchallenge

6 min read

Invoico - yet another invoice and receipts assistant

Mohamed Adel — Wed, 14 Oct 2026 09:35:48 +0000

This is my participation in the Hacktoberfest 2026 Open-Source AI Challenge — Week 2 (Side Hustle).

What I built

I'm mohamedation, and I built Invoico for the challenge: a local invoice and receipt helper (another one, yes i know). The theme this week is side hustle, so the project had to be something you could imagine turning into a small product — with open weights in the loop, and some real measurement to back it up.

The problem I invisioned is pretty ordinary and common. Every few months there is a folder of invoice PDFs and phone photos of receipts, and then someone has to type vendor, date, net, VAT, gross into a spreadsheet. Those files are private. Pushing them through a closed vision API just to skip a boring afternoon of data entry never sat right with me. So for this challenge I built something that stays local. It can be turned into a self hosted or a packaged software and with minor automations, it can work as just taking a photo of the reciept and it automatically extract the data.

What it does

You drop in a PDF, JPG, or PNG. A local open-weight vision model through Ollama (Gemma) reads the page and pulls out the fields — including line items, cash tendered, and change, because till slips love to print a big Cash number that is not the bill. Plain Python then checks whether net + VAT roughly equals gross, whether the line items add up, and whether someone mixed up cash with the total. You review, confirm (notes stick around if you confirm a mismatch as-is), edit or delete later, and export a CSV.

There is also an Overview with charts, and an Analyze step where the same local model looks at the spend snapshot and writes a short briefing. Mixed currencies get an EUR estimate from a static ECB rate file (demo only — more on that below).

Nothing goes out to a cloud API for inference. That was the design from the start for the challenge.

How the side hustle angle fits the challenge

Week 2 asks you to think about the product shape, not only the demo. Here is the path I would take if this ever left the challenge folder.

Not SaaS. User accounts and a shared database would put invoices on someone else's servers, which fights the whole local-first idea.

Not a heavy self-hosted enterprise thing either. The compose file is in the repo if you want to run it that way, but that is not the story.

For a side hustle, packaged software fits better: install it (or one compose up), Ollama locally, SQLite locally. One-time license, or yearly if updates matter when models change. Inference stays on the user's hardware, so there is no per-document cloud bill to pass on. The repo is MIT either way — this challenge entry is open source.

Demo

In the video I walk through uploading a clean invoice, the intentional bad-math sample, confirming a mismatch so the note stays, a real till receipt where Total ≠ Cash, then Overview and Analyze.

A few screenshots:

Code

mohamedation / invoico

Local invoices. local AI

Invoico

Local invoice & receipt assistant. Drop in a PDF or a phone photo, a vision model on your machine pulls out the fields, Python checks the math, you confirm, and you get a CSV for the accountant.

Nothing is sent to a cloud API. That is the product.

I built this for the Hacktoberfest 2026 Open-Source AI Challenge — Week 2 (Side Hustle).

Demo: https://youtu.be/Cl_LL_XIZYI

Side hustle (where this actually goes)

This is not a SaaS. I am not spinning up user accounts and a shared database so your invoices sit on my servers — that would throw away the whole privacy angle.

It is also not an enterprise self-hosted platform. Freelancers do not want to babysit Postgres for a receipt folder.

The real product shape is packaged software: you install it (or docker compose up), Ollama runs on your machine, SQLite stays local. Pay once for…

View on GitHub

ollama pull gemma3:4b
docker compose up --build
# or uvicorn + streamlit — see the README

Stack is FastAPI + Streamlit + Ollama + SQLite. Compose runs the API and UI; Ollama stays on the host. pytest -q is green (15 tests).

How it came together

The flow looks roughly like this:

Upload a receipt or invoice (PDF or image)
       - Prepare the file for processing
       - Use Ollama Vision to extract invoice details and line items
       - Check and correct totals, change, and item sums when needed
       - Validate net amount, VAT, line items, and gross total
       - Save to SQLite, updating existing records with the same hash or invoice number
       - Review everything in the Invoices section
       - Optionally, generate an analysis summary

A few things that i noticed:

Dumping the full Pydantic JSON Schema into Ollama's format made the small model just… drop fields. A hand-written (and AI cleaned) compact schema fixed that.

Gemma 4's "thinking" mode burned the token budget on chain-of-thought and came back with empty content so i used think=False.

On real till receipts from the data set https://huggingface.co/datasets/jsdnrs/ICDAR2019-SROIE small models kept putting Cash tendered or even a store ID like 1950 into the gross amount. I ended up with three layers: clearer prompt, extract cash / change / line items as their own fields, then Python recovery (cash − change or sum of product lines).

Extraction was the obvious model call. Analyze is the second one it builds a spend snapshot. Felt more useful and somewht unique instead of just another sorter or AI OCR."

Numbers

I labelled a small set under eval/ground_truth.csv: four synthetic invoices in samples/ plus three real scanned till slips (Malaysian cash bills from the huggingface dataset.

python eval/run_eval.py --compare gemma4:e2b gemma3:4b

Head-to-head (same images, same prompt)

Model	Core exact*	Gross accuracy	Cash vs total correct†	Avg s/doc
gemma3:4b	0.857 (6/7)	1.000	3/3	2.69
gemma4:e2b	0.571 (4/7)	0.571	0/3	1.22

*Core exact = vendor + gross + currency all right on the same document.

†On the three real slips that print both a bill total and a cash/change block.

Field accuracy (gemma3:4b)

Field	Accuracy
currency	1.00
gross_amount	1.00
cash_tendered	1.00
change_amount	1.00
net_amount	1.00
vat_amount	1.00
vat_rate	1.00
issue_date	0.86
invoice_no	0.86
vendor	0.86
doc_type	0.71

Per document (gemma3:4b)

File	Source	Gross pred	Cash pred	Core	Seconds
invoice_cloudtools.png	synthetic	119.00	—	yes	2.19
invoice_us_hosting.png	synthetic	49.00	—	yes	1.98
invoice_bad_math.png	synthetic	250.00	—	yes	2.50
receipt_cafe.png	synthetic	15.41	—	yes	2.93
image.jpg (BOOK TALK)	real scan	9.00	10.00	yes	2.35
image (1).jpg (McD)	real scan	26.60	100.00	no‡	3.73
image (3).jpg (Bar Wang)	real scan	8.20	8.20	yes	3.17

‡Amounts are right (total 26.60, cash 100.00, change 73.40). Core failed because the vendor came back as the legal entity (Gerbang Alaf Restaurants Sdn Bhd) plus a store number, not the short name McDonald I had in the labels. Wrong label match, not a wrong total.

Same real slips on gemma4:e2b

File	Truth gross	e2b gross	e2b cash
BOOK TALK	9.00	18.00	10.00
McDonald's	26.60	53.20	(wrong / missing)
Bar Wang Rice	8.20	3.30	—

Faster, sure (about 1.2s per doc), but on till receipts it was a mess. So the default in the repo is gemma3:4b.

Line items are a useful second opinion when the model grabs a store ID or doubles something. And validation still matters; the synthetic bad-math invoice (net 200 + VAT 40 ≠ gross 250) is supposed to stay in review.

Why open weights

Privacy first — invoices do not need a cloud vision hop.

Cost is next after you have the hardware, another document is basically free which i think the future will lean more towards this.

And control: could swap gemma4:e2b for gemma3:4b, re-run the same labelled set or improve your review time and so on.

Overall
Best Use of Gemma — extraction and analyze both go through Gemma via Ollama (gemma3:4b by default; e2b still around for comparison) and i might test more open weights models later.

Quick FX note

Overview and Analyze convert mixed currencies to EUR using fx/eurofxref.csv which is a static ECB snapshot (demo, dated 13 October 2026). Not live FX, not auto-updated, not for real bookkeeping or tax. Native currency totals stay visible next to the estimate.

Still rough

The labelled set is small, and real phone photos will keep being messier than the clean samples.

That is my Week 2 entry. Repo and demo are linked above. As always, any feedback is much appreciated.

Twitter Replying Bot that generates color grids

Mohamed Adel — Wed, 02 Nov 2022 14:30:01 +0000

Yet another tweepy tutorial, but we are not complaining.

a little background: i like to create random fractals art (NFT anyone) I can just can spend hours staring at one and seeing all different things. so what's a better way to share my creations? a twitter bot of course, but lets also make it do something else.

you can try it your self by tweeting 'make grid' to @machineation on twitter. the bot will hash your username then use it as a seed to generate a unique color grid based on the username. lets start.

requirements:

python >= 3.10
twitter developer account (not covered in the tutorial)
tweepy
numpy
pillow

if your not familiar with twitter developer account, please Check this because creating the developer account, app, and getting the authentication are not covered in this tutorial.

lets start by installing the required packages..feel free to use virtual environment or pip3 if you have both version of python.

pip install tweepy numpy pillow

after everything is installed, lets create a file called "bot.py" but you can name yours anything you like, and then lets import what we will need.

import tweepy, random, time, os, pathlib, numpy, hashlib
from PIL import Image

after that, we need to add the authentication and create the API object using tweepy. you can read about the tweepy authentication in the docs but essientially, you need the API Key, API Key Secret, Access Token and Access Token Secret

your keys are secret. don't include them in the script and upload them to to any publicly visible cloud. use .env or some other method to keep secrets. for simplicity, the tutorial doesn't cover that

auth = tweepy.OAuthHandler("xxxx", "xxxx")
auth.set_access_token("xxxx", "xxxx")

#create API object
api = tweepy.API(auth, wait_on_rate_limit=True)

wait_on_rate_limit – Whether or not to automatically wait for rate limits to replenish

In order not to reply to the same tweet multiple times and also to get only the mentions that the bot haven't seen yet, we will make sure to save the last mention tweet id. We will save it to a file so that even if we stopped the bot and then resumed, we will start from the mentions we haven't seen yet, not from the beginning.
Let's create 2 functions. One for reading the id from file and one to store the id.

def read_last_seen(FILE_NAME):
  file_read = open(FILE_NAME,'r')
  last_seen_id = int(file_read.read().strip())
  file_read.close()
  return last_seen_id

def store_last_seen(FILE_NAME, last_seen_id):
  file_write = open(FILE_NAME,'w')
  file_write.write(str(last_seen_id))
  file_write.write("\n")
  file_write.close()
  return

Notice that the first function for reading the id takes one parameter which is the file name, and the function to store the id takes 2 parameters, the file name and the id. in the future, if you want to have more functions that store and read different things, you can call the same functions and changing the parameters and we would change "last_seen_id" with "data" for example.

Now, Lets create the function to create the colors grid from the username. I opted to code it as a separate function.

def make_grid(handle):
    hash = int(hashlib.sha256(handle.encode('utf-8')).hexdigest(), 16) % 10**8
    numpy.random.seed(hash)
    # Generate 100x100 grid of random colours
    grid = numpy.random.randint(0,256, (100,100,3), dtype=numpy.uint8)
    im = Image.fromarray(grid).resize((1600,1600), resample=Image.Resampling.NEAREST)

    im.save(os.path.join(os.path.dirname(__file__), "grids/") + handle + '.png')

"handle": the parameter that will be the username that we will pass to the function.

"hash": we will hash the username using sha256 to use it as a random seed for numpy.

"grid": using numpy, we create a grid with random colors (seeded with the username hash). you can make it any size you want.

"im": using pillow to create the 1600x1600 image from the data. you can use any size you want.

we then save the png image in a folder in the same directory called "grids" with the username as the file name.

Next step, let's create the function that will:

Fetch the mentions since last stored tweet id.
Loop over the mentions.
Store the tweet id.
Check if the tweet is not by our bot.
Check if tweet contains specific words.
Check if the tweet doesn't contain extra words and reply with a message if so.
Reply to tweet depending on the matched word.

this means you can expand the bot to do other things based on the tweet content (command). But first, we need to set some variables.

def grid_tweet():
    bot_id = xxxxxxxxxxxx
    FILE_NAME = os.path.join(os.path.dirname(__file__), "grid_last_seen.txt")
    words = ["make grid"]
    message = "Here is your unique color grid, @{}"
    grid_unknown = "@{} If you want a grid, You just need to tweet 'make grid' to Me without any other words and I will create and send You one."

let's go over them:

bot_id

we set this variable so that we can check if the tweet author is not our bot. this way we make sure that if our bot tweeted the same words we are looking for, the bot doesn't reply to itself. you can get the bot id through different ways, but here is a simple one

Through the Browser
you can go to the bot page on twitter, right click anywhere inside the page and click "Inspect" then search for "identifier" in the elements which will look something like this
"identifier": "1572580999673831426"

FILE_NAME

this is the file we will use to read and store the last mention tweet id. This will be used to call the functions we already created and pass the variable to them. We can then have different files for different functions if we want.

words

The list of words we are looking for. you can add more separated with a comma. For our example we are only using "make grid".

message

the message we are going to include in our reply. we are using {} at the end to format it later and add the username to it.

grid_unknown

Another message if the tweet has extra words in addition to "make grid". also using {} to be formatted later with the username.

now let's create the rest of the code.

    while True:
        # Finding tweets that mention our bot
        mentions = api.mentions_timeline(since_id=read_last_seen(FILE_NAME)) 
        # Iterating through each mention tweet
        for mention in mentions:
            # Save the tweet id in the file
            store_last_seen(FILE_NAME, mention.id)
            # Check to see if the tweet author is not our bot
            if mention.author.id != bot_id:
                # Check if the tweet has any of the words we defined in our list after converting the tweet to lower case
                if True in [word in mention.text.lower() for word in words]:
                    # Removes the first part of the mention which is our bot username like so @username
                    command = mention.text.lower().split(' ',1)[1]
                    # Act based on the matched word/command. can later be used to add more functionality.
                    match command:
                        case "make grid":
                            try:
                                # Prints the username and tweet
                                print(f"{mention.author.screen_name} - {mention.text}")
                                print('Creating Grid')
                                # Calls our make_grid function and passing the username.
                                make_grid(mention.author.screen_name)
                                # Set the media to the image created by our function
                                media = os.path.join(os.path.dirname(__file__), "grids/") + mention.author.screen_name + '.png'
                                print("Attempting to reply...")
                                # Reply with the message after formatting to include username and the media
                                api.update_status_with_media(message.format(mention.author.screen_name), media, in_reply_to_status_id=mention.id_str)
                                print("Successfully replied :)")
                            # Error handling. for now it just prints the error.
                            except Exception as exc:
                                print(exc)
                        # If the tweet contains extra words in addition to our command
                        case other:
                            try:
                                print('tweet contains other words')
                                # Reply with the grid_unknown message
                                api.update_status(grid_unknown.format(mention.author.screen_name), in_reply_to_status_id=mention.id_str)
                                print("Successfully replied with explaination :)")
                            except Exception as exc:
                                print(exc)
        # Sleep for 2 minutes
        time.sleep(120)

so at the end, our file will look like this:

import tweepy, random, time, os, pathlib, numpy, hashlib
from PIL import Image

auth = tweepy.OAuthHandler("xxxx", "xxxx")
auth.set_access_token("xxxx", "xxxx")

#create API object
api = tweepy.API(auth, wait_on_rate_limit=True)

def read_last_seen(FILE_NAME):
  file_read = open(FILE_NAME,'r')
  last_seen_id = int(file_read.read().strip())
  file_read.close()
  return last_seen_id

def store_last_seen(FILE_NAME, last_seen_id):
  file_write = open(FILE_NAME,'w')
  file_write.write(str(last_seen_id))
  file_write.write("\n")
  file_write.close()
  return    

def make_grid(handle):
    hash = int(hashlib.sha256(handle.encode('utf-8')).hexdigest(), 16) % 10**8
    numpy.random.seed(hash)
    # Generate 100x100 grid of random colours
    grid = numpy.random.randint(0,256, (100,100,3), dtype=numpy.uint8)
    im = Image.fromarray(grid).resize((1600,1600), resample=Image.Resampling.NEAREST)

    im.save(os.path.join(os.path.dirname(__file__), "grids/") + handle + '.png')
def grid_tweet():
    bot_id = xxxxxxxxxxxx
    FILE_NAME = os.path.join(os.path.dirname(__file__), "grid_last_seen.txt")
    words = ["make grid"]
    message = "Here is your unique color grid, @{}"
    grid_unknown = "@{} If you want a grid, You just need to tweet 'make grid' to Me without any other words and I will create and send You one."
    while True:
        # Finding tweets that mention our bot
        mentions = api.mentions_timeline(since_id=read_last_seen(FILE_NAME)) 
        # Iterating through each mention tweet
        for mention in mentions:
            # Save the tweet id in the file
            store_last_seen(FILE_NAME, mention.id)
            # Check to see if the tweet author is not our bot
            if mention.author.id != bot_id:
                # Check if the tweet has any of the words we defined in our list after converting the tweet to lower case
                if True in [word in mention.text.lower() for word in words]:
                    # Removes the first part of the mention which is our bot username like so @username
                    command = mention.text.lower().split(' ',1)[1]
                    # Act based on the matched word/command. can later be used to add more functionality.
                    match command:
                        case "make grid":
                            try:
                                # Prints the username and tweet
                                print(f"{mention.author.screen_name} - {mention.text}")
                                print('Creating Grid')
                                # Calls our make_grid function and passing the username.
                                make_grid(mention.author.screen_name)
                                # Set the media to the image created by our function
                                media = os.path.join(os.path.dirname(__file__), "grids/") + mention.author.screen_name + '.png'
                                print("Attempting to reply...")
                                # Reply with the message after formatting to include username and the media
                                api.update_status_with_media(message.format(mention.author.screen_name), media, in_reply_to_status_id=mention.id_str)
                                print("Successfully replied :)")
                            # Error handling. for now it just prints the error.
                            except Exception as exc:
                                print(exc)
                        # If the tweet contains extra words in addition to our command
                        case other:
                            try:
                                print('tweet contains other words')
                                # Reply with the grid_unknown message
                                api.update_status(grid_unknown.format(mention.author.screen_name), in_reply_to_status_id=mention.id_str)
                                print("Successfully replied with explaination :)")
                            except Exception as exc:
                                print(exc)
        # Sleep for 2 minutes
        time.sleep(120)

if __name__ == "__main__":
    print('The mighty Machineation is starting...')
    grid_tweet()

and that's it..now all you have to do is start it with:
pyhton bot.py
and tweet from a different account to your bot saying "make grid" and it should reply in a couple of minutes with the color grid.

Twitter Bot that is generating unique color grids

Mohamed Adel — Thu, 27 Oct 2022 15:18:51 +0000

The NFT craze came and went and whether you believe in them or not, no one can deny the possibilities and the coding behind the technology.
I have always been amazed by Fractals and random computer generated art.so what is better than creating a twitter bot that shares the Fractals I generate with the world? a bot that responds to mentions and generate something.

The basic and simple idea behind it is by using tweepy and creating a bot that fetches mentions and check if certain words (command) and then creates something and send it back to the user who tweeted at the bot. that is exactly what I did..just for fun.

if you mention @machineation on twitter with "make grid" then the bot will take your twitter username, hash it, then create a random color grid seeded by the username.

I don't know if that would be an interesting post/tutorial to show how to code such a bot. If anyone is interested, then i will invest some time in it for sure.

Personal Website

Mohamed Adel — Tue, 31 May 2022 18:28:03 +0000

i have been playing with computers all my life. i am from the late dial-up internet era. the modem dialing sounds still feel like the beginning of an adventure to me.

i had the opportunity to shift careers in the last couple of years and got a nice deal freelancing remotely for a abroad company, doing web developments. i manage the server side of things and do what every full stack developer does..breaks things, then fix them.

the idea was to get my freelancing career started and have some extra job on the side, so where does that begins? a website of course.

easier said than done. life happens and i find myself stuck between completing tasks, fighting through life, or just napping..with the occasional gaming now and then (eve online, csgo anyone?)

i still don't know what i can show in my portfolio and what not, so i just wanted to get one going. so i worked on something that has a tribute to couple of things that a like, and an Easter egg...all would be kinda appreciated by fellow developers and geeks, but not so much for any potential clients. its a lot of fun doing stuff like that.

mohamedation