Whether it’s editing PDFs, converting files, or tweaking images, you name it.

So, to keep things private, I built a few simple ones myself.

Why toolou?

I needed a place to host these tools, so I've created toolou.com

Silly name, basic layout, pretty much vibe-coded with v0 and Copilot Edits.

My favourites so far: Word to markdown converter, JSON formatter, and LinkedIn date finder. Let’s take a look!

Word to markdown converter

I wanted to paste documents into LLMs. Some of them, including OpenAI thinking models, do not allow document upload.

I wanted a quick way to go from .docx to markdown, without uploading them into shady web tools.

So I just created a tool on my own!

JSON formatter

It’s as simple as they come, but easily my most-used tool.

Especially helpful when I’m already in the browser and for some reason don’t feel like opening a code editor.

It was also the first one I built, and the one that got this whole thing started.

LinkedIn date finder

Definitely the weirdest one.

I built it because I wanted to see when posts were actually published. Sometimes a post felt oddly outdated, but LinkedIn only shows “1y”- which can mean anything from 12 to 24 months.

I also wanted to get a sense of the best times to post.

I even made a chrome extension based on it!

This was a fun little project on it's own.

Summing up

Are any of these revolutionary? Not at all.

Did I have fun? Absolutely.

Building something just for myself was surprisingly satisfying. You should give it a try too!

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_

• linkedin

Here’s the result: galacticsiege.com. It’s very unfinished, but it exists. I’m now rehauling it to be more human dev friendly.

What’s it about, and what did I learn?

The game is a turn-based strategy inspired by Polytopia. Your goal is to take over every star system on the map by competing with other spacefaring civilisations. You gather energy, build infrastructure, and train units. You've got 30 turns to do it!

I actually used AI for nearly 100% of the code. I only edited about five lines myself, added analytics, threw in the required jam button, and went straight to deployment.

It took around 100 “turns” with @v0 (related to the final code), plus about 30 more in separate chats and random prompts to ChatGPT and Gemini.

When did I find the time?

I was prompting almost exclusively in between other things—waiting in line at the supermarket, brewing coffee, or killing time during some endless build process. The rough edges of the final game probably reflect that.

I really tried to polish it more, but the LLMs just weren’t computing tokens in my favour. At one point, I couldn’t figure out why a game with zero assets had a loading screen. Turns out v0 had added simulated loading... because that’s what real games do.

Why I didn’t just fix it myself?

That was the whole point—it was an experiment to see what LLMs can actually do when left to their own devices.

I do want to finish the game eventually. If you check it out, let me know what you think! The gameplay is definitely broken, but the foundation is there.

What’s next?

I’ll be sharing more thoughts on the whole process soon—like how different LLMs perform on various creative tasks (generating 3D models, writing code, debugging, ideation). Maybe I’ll even write a guide on going from AI slop to something actually deployable.

Are you building side projects with AI? Maybe even games? I’d love to hear about it.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_

• linkedin

Speed

For me, it’s all about how quickly I can go from idea to prototype. I’ve built around 30 different things using v0 so far. It’s still a code-first tool, but the flow is just faster. I can be out on a walk, think of something I want to try, kick off a chat, and check results later. It’s super low-friction, and that matters a lot when you’re juggling ideas.

I’ve even recommended it to friends - and seen them love it too.

Real-world use case

One of my friends, a UX designer, uses it to prepare for workshops with clients. She says it’s a game-changer - she can show something functional that looks close to the final product without sinking hours into building it. That makes feedback way easier and faster.

How I use it?

Here are just a few ways I use v0 regularly:

• Prototyping UIs before starting real dev work

• Building little apps for fun and sharing with friends

• Exploring side-project and business ideas

• Even working on a game (more on that soon)

For all these “scratch” or temporary projects, v0 is amazing. It helps me think through ideas visually and interactively, without getting bogged down in setup. That said - it’s not quite there yet for production-level code.

What could be improved?

V0 still has some rough edges. Things I’d love to see improved:

• Better Git integration

• A more capable code editor

• Automatic handling of runtime errors

• Smarter visual intelligence (like taking screenshots of its output, evaluating, and improving - right now I do that myself)

• Better backend generation when working with integrations (databases, auth, etc. - e.g. Supabase)

• Mobile app support

Conclusion

I’m currently making the most of my paid subscription, and I keep V0 close by for whenever a new idea pops into my head. Some of the projects I’ve shared here actually started there. Only started - it’s what v0 is good for at the moment - growing beyond the prototype is just too frustrating.

I’m also testing out lovable.dev at the moment (BTW there’s a discount code for $25 atm: 25-DISCOUNT-5281).

Have you tried it yet? What’s your take? Want me to drop a few tips or maybe a tutorial?

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_

• linkedin

In small projects you can feel like a magician. With AI wind in your sails, you storm through backlog like crazy. This changes when features pile up and cost of failure increases.

Here’s what I do:

(For windows in most of the cases replace CMD with CTRL!)

🔹 CMD+P - an absolute killer

Start typing - fuzzy file name search across the project

@ … - go to symbol (variable or function name) in the file you’re in

: … - jump to line number

🔹 CTRL+G - jump to line number shortcut

🔹 CMD+Shift+o - jump to symbol

🔹 CMD+Shift+\ - jump to matching bracket ⭐️

🔹 CMD+click - go to definition

🔹 CMD+Shift+P and then „Find all references”

It actually finds places where given function, class or whatever is used. Better than just find all.

In general the command opens a command palette, which I use all the time, but it’s the one everyone (likely) knows.

🔹 VS Code Bookmarks! Check out the extension by Alessandro Fragnani

It lets you bookmark lines in files across the project and jump between them.

Huge time saver when working across many files, often cleaner than looking up got diffs.

🔹 Copy Python Path by kawamataryo

In VS code you can easily copy a relative path. But there’s no option to copy an import statement by right clicking on a symbol or a file.

For months I copied the path and replaced slashes with dots. Then I discovered this extension!

These are life saving in my daily work.

Which ones do you use?

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_

• linkedin

I like coding with AI assistants. They let me focus on what matters - shipping quickly while only tuning the most important details like performance, security or design.

You can’t use AI code completion and chat at all times though. You may be on a plane or in any other offline situation. There are also times where companies don’t want their code to be sent to third parties. Because of that, they impose strict policies on AI tool usage. That’s where local, open LLMs come in.

How good can local LLMs be for coding? Good enough to be useful but definitely not on par with popular offerings like OpenAI or Anthropic models through GitHub Copilot or Cursor. (Even after DeepSeek release, most people swear by Claude Sonnet).

I’d compare completions quality to the early versions of copilot — sometimes making mistakes but overall useful enough to keep them on. The chat quality is OK but agentic capabilities are functional only on more performant machines.

In this short tutorial, we will:

1. Install LM studio and set up our models

2. Set up Continue - a VS Code and JetBrains IDE extension

   1. Code completions (inline suggestions)

   2. Chat

3. Bonus - set up agentic coding with Cline

I’ve tested performance on two machines: M1 MacBook Air (16GB RAM) and M1 Max MacBook Pro (64GB RAM).

The tutorial is compatible with MacOS, Windows and Linux but your model performance may vary. You can also try to replicate this setup in JetBrains IDEs.

Setting up LM Studio - local LLMs

In my opinion, LM Studio is the best and easiest to use local LLM UI. It doesn’t have many options other than model inference (like loading documents), but it serves its basic purpose well.

Go ahead, download and install LM Studio - https://lmstudio.ai.

Open the app. You will be greeted with a quick-start tutorial. Do it if you want or skip it by clicking a button in the upper right corner.

In the sidebar on the left, click 🔍 magnifying glass icon. This will open a model discovery feature which allows you to find and download new LLMs. Make sure to come back here in the future to test some models on your own.

Let’s find and download two models for different purposes.

• Qwen2.5 Coder 3B, Q4_K variant - a small model (~2GB) that will easily fit into your memory. It works great for code completion and will not negatively affect your workflow even if you have only 8GB of RAM. Stick to this one only if you don’t have at least 32GB of memory and a faster GPU (like non-pro Apple M chips)

• Qwen/Qwen2.5-Coder-14B-Instruct-GGUF, Q4_K_M variant - a bigger model, better for chat sessions and agentic use. Use 7B versions on machines with 16GB (V)RAM or less - but only for chat, agentic capabilities at these sizes are quite poor.

If you have more RAM and more compute, play around with some thinking models. I didn’t choose a thinking one for this tutorial, because they are usually not fast enough for use while coding. They are useful for tasks that are not time-sensitive though!

Generally, recommended models shown at the top of the list in LM Studio are good. Frustrated with the number of options? Experiment! Things are changing every week so there’s no one, easy recommendation.

Close the “Discover” window by clicking on the X.

Now let’s enable our local LLM server, so that our coding assistant can use our models. Go to “Developer” section (terminal icon). And flip the “Status: stopped” switch so that it changes to “running”.

Then, click “Select model to load” at the top of the window. Load our 3B model with default settings. For 7B/14B I recommend selecting 20,000 context window length if you want to use coding agents. This costs RAM though! Adjust to your needs.

Setting up Continue - open source Copilot alternative

Start by installing the extension - search for “Continue” in VS Code extensions or go to continue.dev. In VS Code, click install. You should see a new icon in your left sidebar. Click on it.

You will see a text box and a quickstart prompt - ignore it for now.

Before using it, let’s turn off GitHub Copilot completions to avoid conflicts. At the top of your screen, near the search bar, find Copilot icon, click on it and choose “Configure Completions” and then “Disable Completions” from the menu. You can turn them on in the same way afterwards.

Configuring chat

Let’s go back to Continue sidebar. Click on the model selector (by default showing Claude 3.5 Sonnet at the time of writing). Click “+ Add Chat model”.

In the popup window select:

• Provider: LM Studio

• Model: you can leave autodetect and select it later

• Click “Connect”

Now your model selector will show our models. Let’s select one of the installed models and say hi!

You can do all the usual stuff you can do with other coding chats.

Configuring completions

To configure code completion click “Continue” on the right of the status bar. Select “Configure autocomplete options” from the menu. You will see a JSON configuration file. Add this as a property of the main object:

  "tabAutocompleteModel": {
    "apiBase": "<http://localhost:1234/v1/>",
    "title": "Qwen2.5 Coder 3B",
    "provider": "lmstudio",
    "model": "qwen2.5-coder-3b-instruct"
  },

If you want to use another model, just copy it’s name from the “Developer” section of ML Studio.

Hit save, go to some of your code files, start typing and enjoy completions!

(Optional) Agentic coding with Cline

If you’re into agentic coding (and you should be) and have a strong enough machine, let’s explore how to get these capabilities using local models. I’d recommend doing this only if you can run at least a 14B model. Cursor IDE and Copilot Edits using bigger models perform much better, but hey, we’re running local models here! (Which I hope won’t be a trade off in the near future.)

1. Install Cline.

2. After installing, find its icon in the sidebar.

3. You’ll be greeted with a choice: “Get Started for Free” or “Use your own API key”. Select the API key.

4. Select API Provider - LM Studio.

5. Pick desired model from the list (here qwen2.5-coder-14b-instruct ).

6. Click “Let’s go!”

7. Give the agent a task!

In my experience, the generations are a bit slow (one reason is the massive Cline system prompt). That said, it is capable of providing useful code, addressing given tasks well.

Summary

As you can see, local coding assistants have come a long way, making it possible to work with AI even when offline or restricted by company policies. While they may not match the capabilities of cloud-based solutions like GitHub Copilot or Cursor, they offer a practical alternative for those of us who need strict privacy or offline functionality.

The setup works well even on computers with limited resources, though having more RAM and a beefy GPU gives you the flexibility to use larger, more capable models. It might not replace your primary AI coding assistant, but it's definitely worth having as a backup or alternative when privacy and offline access are priorities.

Let me know if you run into any issues or if you have some cool experiences to share!

Check out my other posts related to LLMs.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_

• linkedin

LinkedIn has its issues–not just the hollow content, fake stories, and unoriginal ideas. You can’t even check when someone’s post was published, because the platform hides the exact date behind relative timestamps like "2d" or "1w ago".

I’ve always wanted to create and publish a browser extension. I started a few but never got to releasing them. I guess they were not useful enough. I also found working on the extensions somehow annoying due to limitations of what you can do with them imposed by browsers.

A few days ago I posted about a tool I’ve created allowing to extract LinkedIn post’s exact date from its URL. Someone encouraged me to turn it into a browser extension. Well, two days and several chats with AI later, here I come with the plugin.

I don’t want it to only be about dates, because there are other LinkedIn quirks that I want to change. I’m also looking for something that would give me better analytics about posted content - mine and others’. Hence, I gave it a more general name.

A look at the extension

You can give it a try here.

It’s simple, the plugin adds a real date to each post it sees on your timeline.

It doesn’t work with short post excerpts in the profile view but once you click to see all posts, timestamps are back.

It also works with comments, displaying the date on hover.

Also added a popup for future functionalities.

Uncomplicated, useful, fun to make.

How to develop a Chrome extension?

This method worked well for getting something done quickly. I’d say I started from nothing since last time I tried to develop an extension was about 5 years ago and focused on Firefox. The whole process took me around four hours.

• Start with Google’s hello world tutorial

• Also learn how to modify content of web pages

• Once you have the above running and open in VS Code or Cursor, use Copilot Edits (I used Claude) or Composer mode to quickly make changes. I used Copilot.

• Test and iterate. At some point AI won’t help you anymore and you’ll have to make some tweaks yourself.

• Once you are happy with the extension, read how to publish your extension.

• Create icons and graphics

  • I used lucide icons and merged them to create a logo.

  • You can use an editor like Photopea - an excellent, free, in-browser Photoshop alternative

  • Create banners and screenshots per instructions, I’ve also used Photopea

• Create a privacy policy and host it somewhere. If you have a blog or a website, put it there. Perhaps a google drive link will work as well? I've created this short document - also with the help of ChatGPT and Copilot edits.

• Publish and wait patiently for review. (24h in my case)

LLMs were a huge help here, I only made some tweaks to the code. Preparing everything for the publication was quite some work.

Promotion

I decided to promote the extension on my tools website - toolou.com. I just asked Copilot in Edits mode to create a banner and a page based on a functionality description. I’ve asked Copilot Chat to compile it beforehand, based on the extension codebase. I only changed the placeholder URL for extension download page and placed a screenshot in the proper directory.

Here it is live.

Future

There’s an elephant in the room – I don’t use Chrome that much. Yeah, I have Edge open all the time (just to have a chromium browser on hand) and it supports Chrome extensions. That said, my daily driver is Safari. I really like how performant and power efficient it is. Since a lot of what I do happens in a browser - it matters. So I’d like to give creating a Safari extension a go. My first impression is that it’s much more complex, because you need to ship it via AppStore, but it makes it even a bit more interesting.

As I mentioned before, I have some other issues with LinkedIn. One of them is that they do not really provide a public API. I cannot programmatically fetch even my own posts or stats. That’s worse than Twitter/X, which API at least lets me fetch a count of followers and posts.

Since I’ll ‘ll be sending data to my server for analysis, I have more ideas in mind. I’d love to do analytics on posts you see on the timeline as well as provide AI-powered suggestions for better content. Maybe also highlight posts worth engaging with?

For now, try the extension, and let me know what you think.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_

• linkedin

The first app was supposed to help air travelers with information not available anywhere else. Some parts of the world were getting ready to lift the 100ml/3.4oz liquid limit in carry-on bags thanks to new scanner technology. I wanted to be the first to collect information about airports that have these new scanners. The app would allow you to find out whether you need to worry about the size of your liquids when traveling to your destination.

Sadly, the EU put the change on hold due to problems with the new scanner software. I decided to release the app anyway because I already had all the other information about airports collected in the database. So there’s no liquid limit information, but everything else is there: official websites, locations, airlines involved, etc. I’ve already seen it become useful for people looking for reliable information about smaller airports.

What was cool about working on it? Well, figuring out the deployment and coding sure was exciting, but getting all the data for the website was the biggest challenge. I needed to use multiple data sources, resort to some light scraping, and have an LLM process all of this. I actually did the whole process with little coding by using a self-deployed instance of n8n. I also figured out getting newsletter sign ups, gathering feedback and programatically getting photos for content - as described in the linked articles.

The second app is just a simple collection of browser-based tools. I often need to format some code or perform other small data transformations on the go. I don’t feel comfortable pasting any data into available offerings, so I decided to create some of these tools for my own use and release them to the public. It’s more of a training project; I’ve used AI heavily to code it. It didn’t take that long, and I borrowed many solutions from Airport Registry when building it. The most useful and novel tool is the one that allows you to find the exact date of a LinkedIn post, since LinkedIn hides it. Especially useful when you’re working in social media.

In general, working on these two apps reminded me of how many problems you need to solve when building products. Deployment, UI design, backend, database setup, backups, security, marketing, content creation, and so on. And these two didn’t even need user management, payments, or support! I noticed that the second time was much easier because I had a lot already figured out.

My takeaway, quite obvious really, is that once you solve each of these problems, in your next project you can focus on what matters—creating something valuable for your users. So I plan to keep building and, while doing that, create a set of solutions that I can reuse in other projects. I feel that having this kind of know-how is key to building small products on my own and is also a huge advantage when building with others within companies.

How did the projects perform in December? Nothing extraordinary—and that's perfectly fine. The Airport Registry site received 173 unique visitors, while the tools collection had 44. I kept marketing minimal, only launching Airport Registry on Product Hunt. I’ve been thriving in my day job, spent a lot of time with family, got sick, quickly prototyped two new apps (using AI: v0 and Copilot with Claude are great), fine-tuned some small language models, recorded a podcast, and more. I felt a bit bad about not shipping more after two fun releases, but I also know that I needed this time to take a step back and come back with new ideas.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_
• linkedin

But that’s no reason not to experiment!

The Role of Code Reviews

In my engineering work, I spend a significant amount of time reviewing others' code. In fact, in most companies, developers spend 2-5 hours per week on code reviews. Some find it boring or see it as an extra burden. However, there are three key goals:

1. Ensure quality and catch mistakes
2. Stay up to date with changes
3. Help others improve their programming skills

All of these are critical, but there’s also an indirect consequence of code reviews in modern development practices. Usually, a code review is a step taken before deployment. Performing a swift code review becomes the single most important thing you can do to help the team ship the next feature. I prioritize reviews ahead of my own work.

At most of the places I’ve worked, there’s been discussion about codifying standards for great code reviews to help everyone improve. My current workplace was no exception.

Experimenting with AI

I drafted a set of guidelines for effective code reviews. As I looked at them through the lens of my AI engineering experience, I realized they could make a perfect prompt for a language model. This inspired me to try making AI assist with reviews. My goal was to spot more issues and perhaps even provide automated reviews for the team, even if they weren’t perfect.

The Plan

I devised a plan in minutes. There’s a tool I often use for low-code automations, n8n. I discovered that I could easily connect to GitHub via its API to read code and post review comments.

Prototype Phase

I built a prototype using GPT-4o and tested it with my personal projects. The outputs were, frankly, terrible. The comments were overly polite, and their usefulness got buried under layers of fluff. I shortened the prompt, made it more specific, and explicitly asked the model to be critical in all comments except the summary. I also provided examples of effective feedback.

Version 2 was far more useful but still included some unnecessary and impractical remarks. I encountered several limitations:

1. Tool constraints: n8n, the tool I used to prototype the workflow, didn’t support the latest OpenAI API functions. This resulted in subpar outputs compared to what was possible.
2. Contextual limitations: The diff provided limited context about the project and its tasks. Providing a great review requires understanding the business context.

That said, the AI managed to spot mistakes in the code that I had missed. Some of its outputs were genuinely helpful. The process involved reviewing all generated comments, removing 75% of them, adding my own insights, and then submitting the review. Despite the overhead, this workflow was actually useful enough.

Next Steps

I haven’t gone further yet. To improve the system, I’d need to implement new API functionalities (like JSON outputs), pull extra code and project context from the codebase, and possibly integrate task management software to fetch relevant business information. The approach shows promise, and I’m aware of several companies exploring similar solutions. I want to refine it further and potentially turn it into a small product.

I’m sharing this post as a checkpoint and a possible discussion starter. If you think this is interesting and would like to test it, let me know. I’ve been considering building a version tailored for companies to automate code reviews, as well as one for individuals to help them become better reviewers and save time.

What do you think is the best route?

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_
• linkedin

When you’re building a project as a solo developer, you need a quick way to gather feedback or collect data without reinventing the wheel. While you can always write more code, you often don’t have to. Sometimes you can even ship something with just a frontend! Pre-filled Google Forms can offer a solution in these situations. Whether you need to create a basic contact form, allow order customization, gather feature requests, bug reports, or collect structured data from users, this method is simple, effective, and easy to implement.

The strength of this approach lies in passing the data from your app into the form URL, auto-filling certain fields to save users time and encourage them to complete the form. Also, you may pass identifiers allowing you to integrate this data quickly without manual parsing.

Real-world example: gathering airport data

Let’s say you’re running a project like mine - airportregistry.com, where users can look up and manage information about airports worldwide. You want to let users quickly request corrections or updates to airport data directly from the site.

Instead of asking users to manually enter details about the airport they’re viewing, you can pre-fill these fields in a Google Form with data from your site, making it much easier for them to submit feedback. Here's an example:

const requestInfoLink =
  `https://docs.google.com/forms/` +
  `d/e/1FAIpQLSfAVYhpjNOZR6_gMPJPtlFYPRqGaem_rFb8nQ4CV27VTgmGzA/viewform?usp=pp_url` +
  `&entry.1513837494=${airport.airport}` +
  `&entry.20379740=${airport.iataCode}` +
  `&entry.475896124=${airport.location}` +
  `&entry.166674403=${airport.country}` +
  `&entry.60635846=${airport.continent}`;

With this setup, when a user clicks the feedback link, they’ll be taken to a Google Form with details like the airport name, IATA code, location, country, and continent already filled in. This removes friction and increases the chances that users will provide meaningful feedback.

How to create a pre-filled Google Form

1. Create a new form: Start by creating a new Google Form with the fields you need. For example, you might include fields like “Airport Name,” “IATA Code,” “Location,” etc.
2. Set up pre-fillable fields:
   • Click the three-dot menu (ellipsis) in the upper right corner and choose "Get pre-filled link."
   • Enter some placeholder values in the fields you want to pre-fill. Use easily recognizable placeholders like “AirportNamePlaceholder,” “IATACodePlaceholder,” etc. This makes it easier to identify and replace them in the generated link.
   • Click "Get link" and copy the URL provided by Google.
3. Customize the link:
   • The URL you copied will contain placeholders that look something like entry.123456789=AirportNamePlaceholder.
   • Replace these placeholder values with variables or data from your app, as shown in the example above.

Tada! You saved yourself some time you would waste writing frontend and backend code.

Wrapping up

Pre-filled Google Forms offer a straightforward way to integrate feedback and data entry mechanisms into your app without writing code.

Use the time saved to really focus on providing value with other features in your app.

Do you think this is bad? How many users does your app have? Hm?

If you liked this content, please support me by sharing this post and subscribing to my Newsletter. Also check out the website where I applied this technique - airportregistry.com!

You can also find me here:

• x: horosin_
• linkedin

Other small tips for your SaaS

• Get stock photos for your content automatically
• Newsletter signup form in Next.js for free or lifetime deal
• Scraping Wikipedia for high quality data

I often want to add visually interesting elements to my projects and struggle with content. Let’s say you have a subpage that shows all the posts/any other information related to a city. It would be great to have a photo of said city in the header, wouldn’t it?

You may think that the way to go is to generate something with AI. It may work, but there are many issues with this approach.

There are great free stock photo sites like Pexels or Unsplash. But how to find the right picture?

I stumbled upon this problem while working on one of my side projects. It turns out Unsplash has a great API. In Python, we need to call it manually but there are client packages for JS, Ruby, PHP, mobile, etc.

Unsplash API

The API basically allows you to find photos matching your search query. A few caveats:

1. Make sure you use direct links from Unsplash. Downloading and re-hosting images is not allowed.

2. You must attribute Unsplash and the author.

3. The API is rate limited to 50 requests per hour for unverified apps, 5k after approval and more if you need it.

More on usage guidelines: Unsplash.

Getting started (in-depth guide):

1. Sign up for an account: https://unsplash.com/oauth/applications

2. Go to your apps: https://unsplash.com/oauth/applications

3. Create a “New application”

4. Go to your app and save Access key, we’ll need it in the following steps

Fetching an image

Have a look at this sample function, you can adapt it to your needs.

import requests
import os

# Load Unsplash API key from environment variables
UNSPLASH_ACCESS_KEY = os.getenv('UNSPLASH_ACCESS_KEY')

def fetch_image_info(query):
    url = "<https://api.unsplash.com/search/photos>"
    params = {
        "query": query,
        "client_id": UNSPLASH_ACCESS_KEY,
        "per_page": 1,
        "orientation": "landscape",
    }
    response = requests.get(url, params=params)

    if response.status_code == 200:
        data = response.json()
        if data['results']:
            return data['results'][0]
    elif response.status_code == 403:
            raise ConnectionError("Rate limited or not authorized")

    return None

When you call this function for a “New York” query, you should receive an object like that:

{
   "id": "string",
   "slug": "string",
   "created_at": "string",
   "width": "integer",
   "height": "integer",
   "color": "string",
   "blur_hash": "string",
   "alt_description": "string",
   "breadcrumbs": "array",
   "urls": "object",
   "links": "object",
   "likes": "integer",
   "user": "object",
   "tags": "array",
   "...": "..."
}

You should pay attention to three of them really.

First, urls - this is what you will use in your app.

 "urls": {
    "raw": "<https://images.unsplash.com/photo-1496442226666-8d4d0e62e6e9?ixid=M3w2MjA1MzR8MHwxfHNlYXJjaHwxfHxOZXclMjBZb3JrfGVufDB8MHx8fDE3MjA5MDAxMTd8MA&ixlib=rb-4.0.3>",
    "full": "<https://images.unsplash.com/photo-1496442226666-8d4d0e62e6e9?crop=entropy&cs=srgb&fm=jpg&ixid=M3w2MjA1MzR8MHwxfHNlYXJjaHwxfHxOZXclMjBZb3JrfGVufDB8MHx8fDE3MjA5MDAxMTd8MA&ixlib=rb-4.0.3&q=85>",
    "regular": "<https://images.unsplash.com/photo-1496442226666-8d4d0e62e6e9?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w2MjA1MzR8MHwxfHNlYXJjaHwxfHxOZXclMjBZb3JrfGVufDB8MHx8fDE3MjA5MDAxMTd8MA&ixlib=rb-4.0.3&q=80&w=1080>",
    "small": "<https://images.unsplash.com/photo-1496442226666-8d4d0e62e6e9?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w2MjA1MzR8MHwxfHNlYXJjaHwxfHxOZXclMjBZb3JrfGVufDB8MHx8fDE3MjA5MDAxMTd8MA&ixlib=rb-4.0.3&q=80&w=400>",
    "thumb": "<https://images.unsplash.com/photo-1496442226666-8d4d0e62e6e9?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w2MjA1MzR8MHwxfHNlYXJjaHwxfHxOZXclMjBZb3JrfGVufDB8MHx8fDE3MjA5MDAxMTd8MA&ixlib=rb-4.0.3&q=80&w=200>",
    "small_s3": "<https://s3.us-west-2.amazonaws.com/images.unsplash.com/small/photo-1496442226666-8d4d0e62e6e9>",
 },

Second, user - you will use this info for proper attribution, namely:

• user.name : Author name

• user.links.html : Link to their profile, you must use. Make sure to append utm_source=your_app_name&utm_medium=referral to it, per guidelines.

Third, alt_description , make sure to add it to your final IMG tags for accessibility and SEO.

This piece of code is really everything you need to get going. With one caveat.

Watching for rate limit

When you’re in initial demo mode, you will only have 50 requests per hour. When trying to fetch more images, hitting rate limit is a given. What to do?

Simply wait for a bit if the function above throws ConnectionError. I wait for around 70 seconds.

Also mind that if no results are found, you will receive None. In this case I am using a simplified query (country instead of the city).

Once the website is online, you can request higher quota in the dashboard.

Summary

We've covered how to use Python and the Unsplash API to automatically fetch photos for your apps and websites.

I hope you’ll build something cool with it. Send your projects my way in the comments or on Twitter.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter. I will soon be releasing a crazy interesting project that uses this solution!

You can also find me here:

• x: horosin_

• linkedin

SendFox is a popular newsletter service built by AppSumo. The company is famous for its store with lifetime deals for software. The product has limitations and is not a perfect solution but if you need a solid tool with predictable cost, it may be just the fit for you. There's a generous free tier as well.

There aren't many examples online for how to create a sign up form outside of embedding one. They don't look the best and don't play nice with JS frameworks.

Let's create a form component and an API route in Next.js that will give us full control.

I am using shadcn/ui for ui components and lucide-react for icons. You can easily swap these components for something else.

Set up

Skip if you're adding this to an existing app.

If you want to follow this tutorial from scratch, perform the following steps.

1. Set up Next.js app with shadcn/ui - link

2. Add components: npx shadcn-ui@latest add button input

3. Install icons pack: npm i lucide-react

You're good to go.

SenfFox API

SendFox has a very basic API documentation, which you can find here: https://help.sendfox.com/article/278-endpoints.

You will need to get an API key from your SendFox account. Go to the settings, API section and click "Create new token".

Copy and store safely.

API route

Let's start with an API route that will handle our sign up logic.

You can add more verification to this code to pre-filter spammy sign-ups.

You may want to also save emails somewhere other than SendFox for redundancy.

I've created a file app/api/newsletter/route.ts with the following content:

export async function POST(request: Request) {
  const { email } = await request.json();

  if (!email) {
    return Response.json({ error: "Email is required" }, { status: 400 });
  }

  const response = await fetch("<https://api.sendfox.com/contacts>", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.SENDFOX_TOKEN}`,
    },
    body: JSON.stringify({
      email,
    }),
  });

  if (!response.ok) {
    return Response.json({ error: "Failed to subscribe" }, { status: 500 });
  }

  return Response.json({ message: "Subscribed successfully" });
}

You can test it in Postman or via curl or just jump in to create a form.

Form component

Create a file app/components/send-fox-form.tsx with the following content:

"use client";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { Loader2 } from "lucide-react";
import { useState } from "react";

type FormStatus = "idle" | "loading" | "success" | "error";

const ButtonLoading = () => (
  <Button disabled>
    <Loader2 className="mr-2 h-4 w-4 animate-spin" />
    Please wait
  </Button>
);

const SendFoxForm = () => {
  const [email, setEmail] = useState("");
  const [status, setStatus] = useState<FormStatus>("idle");
  const [errorMessage, setErrorMessage] = useState("");

  const handleSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
    event.preventDefault();
    setStatus("loading");
    setErrorMessage("");

    try {
      const response = await fetch("/api/newsletter", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ email: email.trim().toLowerCase() }),
      });

      const data = await response.json();
      if (response.ok) {
        setStatus("success");
      } else {
        setStatus("error");
        setErrorMessage(data.message || "Failed to subscribe");
      }
    } catch (error) {
      setStatus("error");
      setErrorMessage("An error occurred while trying to subscribe.");
    }
  };

  return (
    <div className="w-full">
      <form
        onSubmit={handleSubmit}
        className="flex w-full max-w-md items-center space-x-2 mx-auto"
      >
        <Input
          className="w-full"
          type="email"
          placeholder="Email"
          name="email"
          value={email}
          onChange={(e) => setEmail(e.target.value)}
          required
          disabled={status === "loading" || status === "success"}
        />
        {status === "loading" ? (
          <ButtonLoading />
        ) : (
          <Button type="submit" disabled={status === "success"}>
            {status === "success" ? "Subscribed!" : "Subscribe"}
          </Button>
        )}
      </form>
      <div className="pt-2 min-h-[1em]">
        {(status === "idle" || status === "loading") && <p>&nbsp;</p>}
        {status === "error" && (
          <p className="text-sm text-red-500 text-center">{errorMessage}</p>
        )}
        {status === "success" && (
          <p className="text-sm text-muted text-center">
            Subscription successful! Thank you for joining.
          </p>
        )}
      </div>
    </div>
  );
};

export default SendFoxForm;

The SendFoxForm component handles the subscription logic and user interaction. It utilizes useState to manage the form's status and user input. The form includes three states: idle, loading, and success, each guiding the user through the subscription process with appropriate feedback.

Business Logic Overview:

1. Form Submission Handling:

   • When the form is submitted, it prevents the default form behavior and sets the status to loading.

   • The email input is trimmed and converted to lowercase before being sent to the server.

2. API Interaction:

   • The form makes a POST request to the /api/newsletter route with the user's email.

   • If the response is successful (response.ok), the status changes to success.

   • If there's an error, the status changes to error, and an appropriate error message is displayed.

3. User Feedback:

   • While the form is submitting, a loading button is displayed to inform the user to wait.

   • If the subscription is successful, a "Subscribed!" message is shown, and further input is disabled.

   • If there is an error, an error message is displayed, guiding the user to rectify the issue.

Conclusion

You now have a working SendFox newsletter sign up form in your Next.js app.

While SendFox is in no way perfect, it may be the right choice for your first newsletter or a side project.

Personally, I used it for one of my upcoming projects and it's been a good experience so far. It lacks features related to managing multiple lists of contacts so may not be the best choice if you're running a few projects with separate domains.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter. I will soon be releasing a crazy interesting project that uses this solution!

You can also find me here:

• x: horosin_

• linkedin

Wikipedia was ranking high in my searches but I quickly found that the tables are as unstructured as the ones you typically create in Word or Google Docs. There was no consistency in columns and naming conventions. This at first discouraged me but after failing to find another datasource, I gave it a go. And I ended up using it for my project.

Let me show you how to quickly load Wikipedia data for your data analysis. I was astonished how easy it is.

Big thanks to all Wikipedia contributors doing the hard work.

Method 1: Loading tables in Google Sheets

This one feels like magic.

Use this formula in one cell, and it will expand the entire table scraped from Wikipedia.

=importHTML(WIKIPEDIA_URL, "table", NUMBER_OF_TABLE_ON_THE_PAGE);

Let’s say you want to fetch a list of all EU countries with their population count, GDP, language and other essential data.

There’s a Wikipedia page containing all of this information and citing sources of the information(!): https://en.wikipedia.org/wiki/Member_state_of_the_European_Union.

The table containing this info is the second table on the page (the first one is the little summary table). The formula will look like:

=importHTML("https://en.wikipedia.org/wiki/Member_state_of_the_European_Union", "table", 2);

After running it, you’ll get all of this data in your Google Sheets, ready to analyze or export.

Google Sheets can also read lists! Full docs here.

Method 2: Pandas and Python

I was surprised to find out that the most popular library for data analysis for Python has a feature equivalent to Google Docs.

import pandas as pd

url = "https://en.wikipedia.org/wiki/Member_state_of_the_European_Union"

dfs = pd.read_html(url)

df = dfs[1]

read_html function from pandas takes site URL as an input and fetches all tables to a list of dataframes. Again, the second one is what we are looking for. And it’s ready for further analysis!

Since Google Docs was not something I intended to stick with, I used this method in addition to method 3 to gather data from several pages.

Full documentation here.

Method 3: Python and Beautiful Soup

Well, Beautiful Soup is a go to library for parsing HTML in Python ecosystem. I looked for easy solutions but I needed to fall back on it in the end. The reason was I needed to get not only data from tables but also from headings that preceded them.

Instead of writing the code from scratch, I recommend using ChatGPT and refining its output. I basically pasted a url, said what I needed to scrape and got the script without giving any guidance.

If you wanted to do something similar to me - getting all tables from a page and data from multiple levels of headings preceding them - you would do something like this.

import requests
from bs4 import BeautifulSoup

response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')
tables = soup.find_all('table', {'class': 'wikitable'})

all_airports = []

for table in tables:
  continent = table.find_previous('h2').find('span', class_='mw-headline').text
  region = table.find_previous('h3').find('span', class_='mw-headline').text
  country = table.find_previous('h4').find('span', class_='mw-headline').text

  rows = table.find_all('tr')

  for row in rows[1:]:
      cols = row.find_all('td')

      # here push the data wherever you need

It looks pretty neat, doesn’t it? I was worried that scraping “by hand” would be a pain but actually Wikipedia usually has a pretty clear, predictable HTML structure. It varies page to page but adheres to the same patterns.

This method in addition to using pandas helped me get all the data I needed.

Summary

As you can see, getting data for your analyses or side projects can be nice and easy.

There is a catch though - there are no data consistency mechanisms in tables inside Wikipedia pages. This means that after using any of the above methods, you’ll likely need to do some cleaning and check for mismatches in naming conventions. Some regular expressions will come in handy as well.

At times I am cynical about technological progress but discovering that information access can be so straightforward makes me feel that I can really stand on the shoulders of giants when building on my own.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter. I will soon be releasing a crazy interesting project I needed data from Wikipedia for!

You can also find me here:

• x/twitter: horosin_

• linkedin

You may be guarded by countless level of corporate hierarchy but eventually you will either be asked to debug a production issue or you will be in a job that will require it.

This article is aimed primarily at software engineers but also QAs, managers, leads, solution engineers.

How does an issue reach you?

You get an invite to a call, you’re tagged in jira ticket, on slack, or DM’ed. Ok, cool.

Someone is asking you to drop a feature you’ve been working on, switch context and help. Annoying, I know. Give yourself 90 seconds for grief and move on.

If someone is asking you for urgent help with production issue, they mean it.

Before you start, make sure your direct superior/manager/leas knows you are switching priorities.

And if you start investigating, make sure everyone knows it, so other people are not wasting time doing the same.

As you’ll see, comms are the key.

Communication

Before we get to any technical tips, let’s start with communication. I’ll mention some tools, some should be a part of the system already in place, automatic procedures. If they’re not, you should introduce them.

Incident slack channel

If you’re reading this in early XXI century, you have a company chat app.

Make sure there is a channel where all the people that can help with the problem or need information about it have a place to talk. Invite people and ask them to add anyone interested.

Spam this channel with progress updates.

Example name: inc-2023-01-04-sign-up-down . It can also include a ticket number instead of a date.

Cadency

Depending on the criticality of the issue, post summaries of what’s going on.

• If it’s an urgent issue that is classified as P1 (priority 1, critical system down, significant financial impact), you’re likely to post summaries each hour or two.
• If it’s a long running issue with lower priority, begin the day with the plan for what’s next and close the day with progress summary.

Message template

Here’s what I use:

Summary of [name/ticket] incident investigation as of 4PM, Jan 18th

Resolved: yes/no/partially

∑ Brief summary

• we know that the cause of the issue is: …
• fix by … didn’t work, we’re trying …., estimated test at …
• replication is hard, streamlining it

⏭️ Next steps

• […]

🧠 Other notes

• [ideas and resources]

These updates may not get reactions but many people will read them and quietly thank you for your thoroughness. If you are a recipient of those, like them, react with 👀 emoji, or whatever. Feedback is always good.

Forward daily updates on the main channel for issue discussions or on the team channel, so people less involved but still interested or able to help can see them.

Escalation

Whenever you are stuck - flag it and ask for help. You have an important task, it’s not worth being quiet. If your direct manager isn’t listening - try their manager.

When asking people for help, state how urgent is the question and when you need it done.

Don’t sit alone on an unresolved issue. You work with other specialists, present your idea to someone, get feedback.

Getting essential information

There are few types of information you are going to need. Apart from what comes with your programming experience.

1. How to reproduce the issue? Steps taken, environment details.
2. Input and output data - input that is causing the issue, the erroneous output, the right output.
3. Logs with real-world examples of the issue in the wild.
4. System knowledge - think knowing the part of the product in question, documentation.
5. Initial estimate of impact on customers.

If you lack any of these at the start, work hard to get them first. I’ve been asked to work on a bug that no one could reproduce a few times. Customers that encountered it, didn’t have time to jump on a call. Imagine how hard it was to work on such an elusive problem.

You are OK to push back in these situations. Make sure to be collaborative with your customer-facing colleagues that will help gather this information. If you can, tell them exactly what you need. You can use the list above.

Regarding the point 5, estimating impact, it will need to be done properly either by you or someone else in the end. It will be needed for proper customer communication.

Working on the issue

Finding and fixing a bug is a little bit like doing science. You are likely going to follow a process like this:

1. Construct a hypothesis
2. Test it by doing experiments
3. Analyze your data and draw a conclusion
4. Come up with a fix
5. Test the fix
6. If it doesn’t work → repeat

Make sure to write down your current hypothesis and log any additional ideas. Keep track of what you checked and what you didn’t. If the work will end up taking long time or you’ll be forced to hand it over to someone else, these notes will be extremely useful.

In general, maintain a log of what you experimented with. This will help you avoid running in circles and providing good updates for the team.

Create tools!

Whenever an experiment requires manual labour and you have to do it multiple times, create small tools helping you do it. As an example, if experimenting requires decrypting some values stored in your system, create a piece of code that will do that en masse instead of using online tools and console programs all the time.

If you need to parse some files and you are opening tens of them and looking for clues - create a small JS website that will help you extract the right information.

Mini-tools will help you move faster and you won’t need to repeat the same work. Of course make them only when it is necessary.

At many projects of mine, these tools later became a part of regular testing and development processes.

After the incident

Your company likely will have a process, usually it is called RCA - Root Cause Analysis. Someone should schedule a meeting with all of the people involved in the work and prepare a document, later distributed to everyone interested.

On top of this note, relevant work preventing such incidents in the future should be scheduled.

The point of the whole exercise is to learn from mistakes.

This meeting should not be geared towards blaming individuals. It should point out where the processes failed.

When everything is fixed, make sure everyone knows it is the case.

If you spent some extra hours working on it, ask to be compensated or to be able to work less in the coming days. Make sure to note down what you did and how it helped the company and use it on your next evaluation meeting.

Summary

If you have dealt with production issues at your job, this guide probably sounds familiar. If you are yet to be asked to fix something, this article gives you the proper frame of mind.

Remember:

• communication is the key, don’t neglect it
• fixing a bug is like doing scientific research, form and test hypotheses, note everything down
• create tools that will help you with manual work
• take and give credit, forget about the blame

What are your experiences with troubleshooting live issues?

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_
• linkedin

One of my aims this year is to publish more, be more open about how I work and what I find interesting in my areas of expertise. What metrics can I attach to it? One is certainly a number of posts, the other could be how many people find them interesting enough to follow me.

To see how these metrics change over time, I decided to create a small dashboard that would track their historical values. I decided to start with X/Twitter.

Check out the dashboard created in this tutorial here: https://horosin.github.io/metrics-dashboard/

Full code: https://github.com/horosin/metrics-dashboard

You may have heard that X restricted access to their API last year. They did, but they still allow us to access our own basic metrics (contrary to platforms like LinkedIn - shame on you Microsoft, I have to scrape in order to access my data).

What we’re going to build

There will be a few pieces of software to write/configure:

• The code for fetching the data from X
• A script saving the data somewhere (in this case in the JSON file in GitHub repository)
• Schedule to run the code periodically - every day at a given time
• Dashboard to present the data (simple single HTML file using chart.js)
• GitHub Pages to host the dashboard

The best part is that we can do all of that for free (including compute).

Set up

Twitter application

Setting up a Twitter application in the developer section is a prerequisite for accessing Twitter's API, which is essential for fetching data like follower counts, posting tweets, or accessing other Twitter resources programmatically. Here's a step-by-step guide to get you started.

1. Navigate to the Twitter Developer Site: Go to Twitter Developer and sign in with your Twitter account. If you don't have a Twitter account, you'll need to create one. Complete the application/sign up.

2. Go to the Developer Dashboard: Access your Twitter Developer Dashboard.

3. Create a Project: Click on "Create Project". You will be asked to provide a project name, description, and use case. Fill these out according to your project's needs.

4. Create an App within Your Project: After creating your project, you'll have the option to create an app within this project. Click on "Create App" and fill in the necessary details like the App name.

5. Get Your API Keys and Tokens: Once your app is created, you will be directed to a page with your app's details, including the API Key, API Secret Key, Access Token, and Access Token Secret. Save these credentials securely; you'll need them to authenticate your requests to the Twitter API.

Project

Now let’s get to coding. Create a new directory on your system and open a console there.

mkdir metrics-dashboard
cd metrics-dashboard

Make sure to initialize a Git repository, and later connect it to a GitHub project.

Initialise node.js project and install some packages that we’re going to need to authenticate with the API.

npm init
npm i dotenv oauth-1.0a crypto

Create a .env file with all the keys acquired from X before. DO NOT commit this to the repository. This is only to test the script locally.

TWITTER_API_KEY=''
TWITTER_API_SECRET=''
TWITTER_ACCESS_TOKEN=''
TWITTER_ACCESS_SECRET=''

Create the .gitignore file to avoid this. Sample below contains other paths we’d want to ignore.

node_modules/
.env
.DS_Store
dashboard/data/

Fetching the data

First, we’ll write a Node.js script called to fetch follower statistics from your platform's API. We'll use standard fetch library to make the API calls and oauth-1.0a to authenticate with X. After fetching the data, we will write results to a JSON file that will serve as our database. This will be handled by a separate script. To make the output accessible to it, we will write it to an environment file available in GitHub Actions.

I am using node 20.

Create a file called x_fetch_data.js in the root of our project.

require('dotenv').config();
const OAuth = require('oauth-1.0a');
const crypto = require('crypto');
const fs = require('fs');

// Initialize OAuth 1.0a
const oauth = OAuth({
  consumer: {
    key: process.env.TWITTER_API_KEY, // Read from environment variable
    secret: process.env.TWITTER_API_SECRET // Read from environment variable
  },
  signature_method: 'HMAC-SHA1',
  hash_function(base_string, key) {
    return crypto.createHmac('sha1', key).update(base_string).digest('base64');
  }
});

const token = {
  key: process.env.TWITTER_ACCESS_TOKEN, // Read from environment variable
  secret: process.env.TWITTER_ACCESS_SECRET // Read from environment variable
};

const url = 'https://api.twitter.com/2/users/me?user.fields=public_metrics';

const fetchTwitterFollowerCount = async () => {
  const requestData = {
    url,
    method: 'GET',
  };

  // OAuth header
  const headers = oauth.toHeader(oauth.authorize(requestData, token));
  headers['User-Agent'] = 'v2UserLookupJS';

  const response = await fetch(url, {
    method: 'GET',
    headers
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  console.log(data);

  // Extract the metrics
  const metrics = data?.data?.public_metrics;

  // Write the metrics to the environment file
  fs.appendFileSync(process.env.GITHUB_OUTPUT, `METRICS=${JSON.stringify(metrics)}\n`);
};

fetchTwitterFollowerCount().catch(err => console.error(err));

To test the script, you can run:

GITHUB_OUTPUT=testoutput node x_fetch_data.js

You should see your X metrics in the output, as well as in the testoutput file:

metrics={"followers_count":288,"following_count":302,"tweet_count":1381,"listed_count":0,"like_count":591}

Saving the data

To save the data, create another script in a file x_save_data.js . It will take the output from the environment and append it to the ./data/x.json .

Make sure to create this file first and commit it to the git repository. It should have an empty array as its content.

[]

The script also doesn’t add a duplicate record if the data was already fetched that day. It overwrites the old one instead.

const fs = require('fs');

// Parse the JSON string from the environment variable
const metrics = JSON.parse(process.env.METRICS);
const path = './data/x.json';
const now = new Date();
const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;

let data = [];
if (fs.existsSync(path)) {
    data = JSON.parse(fs.readFileSync(path));
}

const todayIndex = data.findIndex(entry => entry.date === today);
if (todayIndex > -1) {
    data[todayIndex] = { date: today, ...metrics };
} else {
    data.push({ date: today, ...metrics });
}

fs.writeFileSync(path, JSON.stringify(data, null, 2));

You can test the script by editing testouput file by adding single quotes around the JSON and then running the following. File edit I necessary, as GitHub Actions environment behaves differently and doesn't need the quotes.

# load output from the previous script
set -a; source testoutput; set +a;
node x_save_data.js

Scheduled GitHub Action

Now, let’s create a file with GitHub action code. It will run every day at a specified time and fetch our metrics. It will then save them and commit to the repository.

Save the following code under .github/workflows/fetch_x_data.yml .

name: Fetch X Data

on:
  schedule:
    # Runs at 4 AM UTC
    - cron: '0 4 * * *'
  workflow_dispatch: # This line enables manual triggering of the action

jobs:
  fetch_data:
    runs-on: ubuntu-latest

    permissions:
      contents: write
      pull-requests: write

    steps:
      - name: Check out the repository
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"

      - name: Install dependencies
        run: npm install

      - name: Fetch Data from Platform X
        id: fetch_data
        run: node x_fetch_data.js
        env:
          TWITTER_API_KEY: ${{ secrets.TWITTER_API_KEY }}
          TWITTER_API_SECRET: ${{ secrets.TWITTER_API_SECRET }}
          TWITTER_ACCESS_TOKEN: ${{ secrets.TWITTER_ACCESS_TOKEN }}
          TWITTER_ACCESS_SECRET: ${{ secrets.TWITTER_ACCESS_SECRET }}

      - name: Save data
        run: node x_save_data.js
        env:
          METRICS: ${{ steps.fetch_data.outputs.METRICS }}

      - name: Commit and push if there's changes
        run: |
          git config --global user.email "action@github.com"
          git config --global user.name "GitHub Action"
          git add data/x.json
          git commit -m "Update data for Platform X" || exit 0  # exit 0 if no changes
          git push

Run the action manually by committing the code and then going to “Actions” section of your project on GitHub and triggering it from there.

Dashboard

Okay, how about presenting the data? I didn’t want to mess around with simple HTML, so I asked ChatGPT to generate it for me.

Create an index.html file in the dashboard folder. We’re not using the main directory of our project in order to avoid hosting the data fetching code alongside the HTML.

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Twitter Dashboard</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
  <style>
    body {
      font-family: Arial, sans-serif;
      margin: 0;
      padding: 0;
      display: flex;
      flex-direction: column;
      align-items: center;
    }

    .chart-container {
      width: 80%;
      max-width: 1000px;
    }

    canvas {
      max-width: 100%;
    }

    h1 {
      text-align: center;
      margin-top: 20px;
    }

    h2 {
      text-align: center;
      margin-top: 20px;
    }
  </style>
</head>

<body>
  <h1>Twitter Dashboard</h1>

  <h2>Number of Followers</h2>
  <div class="chart-container">
    <canvas id="followersChart"></canvas>
  </div>

  <h2>Number of Tweets</h2>
  <div class="chart-container">
    <canvas id="tweetsChart"></canvas>
  </div>

  <script>
    fetch('data/x.json')
      .then(response => response.json())
      .then(data => {
        const dates = data.map(item => item.date);
        const followers = data.map(item => item.followers_count);
        const tweets = data.map(item => item.tweet_count);

        const minFollowers = Math.min(...followers) - 100;
        const minTweets = Math.min(...tweets) - 100;

        const followersCtx = document.getElementById('followersChart').getContext('2d');
        const tweetsCtx = document.getElementById('tweetsChart').getContext('2d');

        new Chart(followersCtx, {
          type: 'line',
          data: {
            labels: dates,
            datasets: [{
              label: 'Followers',
              data: followers,
              backgroundColor: 'rgba(54, 162, 235, 0.2)',
              borderColor: 'rgba(54, 162, 235, 1)',
              borderWidth: 1
            }]
          },
          options: {
            scales: {
              y: {
                beginAtZero: false,
                min: minFollowers
              }
            }
          }
        });

        new Chart(tweetsCtx, {
          type: 'line',
          data: {
            labels: dates,
            datasets: [{
              label: 'Tweets',
              data: tweets,
              backgroundColor: 'rgba(255, 99, 132, 0.2)',
              borderColor: 'rgba(255, 99, 132, 1)',
              borderWidth: 1
            }]
          },
          options: {
            scales: {
              y: {
                beginAtZero: false,
                min: minTweets
              }
            }
          }
        });
      });
  </script>
</body>

</html>

Commit it to the repository.

(optional) If you want to test it locally, do so by copying the data folder to the dashboard folder and launching a simple server inside it.

cp -r data dashboard/
cd dashboard
# start server with Python if you have it installed (version 3)
# otherwise, use other way e. g. https://gist.github.com/willurd/5720255
python -m http.server 8000

Dashboard deployment to GitHub Pages

Now that we have our dashboard, it’s time to present it to the web!

If you are using a free account on GitHub, your page needs to be public, as well as the whole repository.

Create a .github/workflows/deploy_dashboard.yml file.

name: Deploy to GitHub Pages

on:
  schedule:
    # redeploy after data update
    - cron: '0 5 * * *'
  push:
    branches:
      - main
  workflow_dispatch: # This line enables manual triggering of the action

permissions:
  contents: read
  pages: write
  id-token: write

# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
concurrency:
  group: "pages"
  cancel-in-progress: false

jobs:
  deploy:
    permissions:
      pages: write      # to deploy to Pages
      id-token: write   # to verify the deployment originates from an appropriate source

    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}

    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Pages
        uses: actions/configure-pages@v4

      - name: Copy data to dashboard folder
        run: cp -r data dashboard/

      - name: Update pages artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: dashboard/

      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4 # or specific "vX.X.X" version tag for this action

The action should deploy the page. You can find the URL in your Github project settings or in the Actions section in the workflow output.

Again, you can find mine here: https://horosin.github.io/metrics-dashboard/.

Summary

And there you have it! A complete, automated system to track your social media (X) metrics, automate data fetching, save historical data, and visualize the trends. With this setup, you can extend the functionality to other platforms and metrics, creating a comprehensive dashboard for all your analytical needs. Let me know if it’s something you’d like to read about.

If you liked this content, please support me by sharing this post and subscribing to my Newsletter.

You can also find me here:

• x/twitter: horosin_
• linkedin

What are we going to build any why?

LLMs are a new hot piece of technology that everyone is experimenting with. Managed services like OpenAI are the cheapest and most convenient way to use them. You can use their LLMs only for a small fee and for an approval to train new versions on your data (in some cases).

In certain applications, it is required to run an LLM on our own. You may want to process sensitive data (medical records or legal documents) or get great quality output in a language different than English. Sometimes you have a specialised task that doesn’t require expensive big models from OpenAI.

Open source LLMs are matching quality of big players like OpenAI but still require a lot of expensive compute resources. There are smaller models available that can run on weaker hardware and perform well enough.

As an experiment let’s deploy a smaller open source LLM on AWS lambda. Our goal is to learn more about LLMs and docker-based lambdas. We will also evaluate performance and cost to determine if any real-world applications are feasible.

For this project, we are going to use Microsoft Phi-2 model, 2.7 billion parameter LLM that matches quality of outputs from 13B parameter or more open-source models. It was trained on a large dataset and is a viable model for many applications. From my experience it hallucinates a lot but otherwise provides useful outputs. Its size is perfect for AWS Lambda environment.

We will download the model from Huggingface and run it via llama-cpp-python package (bindings to the popular llama.cpp, heavily optimised model CPU runtime). We will use smaller, quantised version but even the full one should fit in Lambda memory.

We will create an HTTP REST endpoint via lambda URL mechanism, that for a given call:

PROMPT="Create five questions for a job interview for a senior python software engineer position."

curl $LAMBDA_URL -d "{ \"prompt\": \"$PROMPT\" }" \
    | jq -r '.choices[0].text, .usage'

(jq command used to decode returned JSON)

Provides LLM output alongside execution details:

Instruct: Create five questions for a job interview for a senior python software engineer position.
Output: Questions: 

1. What experience do you have in developing web applications?
2. What is your familiarity with different Python programming languages?
3. How would you approach debugging a complex Python program?
4. Can you explain how object-oriented programming principles can be applied to software development? 
5. In a recent project, you were responsible for managing the codebase of a team of developers. Can you discuss your experience with this process?

{
  "prompt_tokens": 21,
  "completion_tokens": 95,
  "total_tokens": 116
}

For this tutorial you need to know basics of: programming, docker, AWS, Python.

I am using an M-series Mac, so as a default, we’re going to aim at deployment to ARM AWS Lambda, as it simply costs less for more performance. Instructions how to deploy x86 version are included.

Environment setup (AWS, Docker and Python)

I won’t dive into the basics here, if you don’t have the tools installed, please follow these resources.

1. You need AWS account and AWS CLI installed and configured.

   1. Good tutorial from google search: tutorial.

   2. Official docs, including if you’re using SSO: AWS official tutorial.

2. You also need docker: docker docs.

3. An IDE, I am using Visual Studio Code.

Set up lambda function with docker locally

Let’s start with getting local environment running. If you need more information than I included here, check out official AWS documentation.

We will store every file in single project directory, without subfolders.

First we will need a basic Python lambda function handler. In your project folder, create a file called lambda_function.py.

import sys

def handler(event, context):
    return "Hello from AWS Lambda using Python" + sys.version + "!"

We will also create a requirements.txt file, in which we specify our dependencies. Let’s start with AWS library for interacting with their services, just as an example.

boto3

Then, we need to specify our docker image composition in Dockerfile file. Comments document what each line does.

FROM public.ecr.aws/lambda/python:3.12

# Copy requirements.txt
COPY requirements.txt ${LAMBDA_TASK_ROOT}

# Install the specified packages
RUN pip install -r requirements.txt

# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}

# Set the CMD to your handler
CMD [ "lambda_function.handler" ]

Finally, we will create a docker-compose.yml file to make our life easier when running and building the container.

version: '3'

services:
  llm-lambda:
        image: llm-lambda
    build: .
    ports:
      - 9000:8080

OK, done! Make sure your docker engine is running and type in the terminal:

docker-compose up

The container should build and start. Our lambda is available under a long URL below (quirks of official Amazon image).

To test if the lambda is running, open another terminal window / tab and type in:

curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'

Now you can come back to the tab you ran docker-compose in and type ctrl-c to stop the container.

You can put this test code in a bash script, as seen in the project repo. Also, it will be useful to create a .gitignore file, if you’re going to version control this project.

Run an LLM inside a container

Now that we have a working lambda, let’s add some AI magic.

To run an LLM, we need to add llama-cpp-python to our requirements.txt.

boto3
llama-cpp-python

To build it, we need to introduce a docker build stage. This is because default amazon docker image doesn’t include build tools required for llama-cpp. We are doing a pip install with CMAKE_ARGS="-DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS" flags, in order to use multi-threaded optimisations.

The code below also includes downloading the model. Community hero, the Bloke, is sharing compressed (quantised, less computationally intensive but lower quality) versions of models, ready to download here. To make use of them, we can install the huggingface CLI and run appropriate command. You can switch the repository (TheBloke/phi-2-GGUF) and the model (phi-2.Q4_K_M.gguf) to whatever you like, if you want to deploy a different model.

RUN pip install huggingface-hub && \
    mkdir model && \
    huggingface-cli download TheBloke/phi-2-GGUF phi-2.Q4_K_M.gguf --local-dir ./model --local-dir-use-symlinks False

# Stage 1: Build environment using a Python base image
FROM python:3.12 as builder

# Install build tools
RUN apt-get update && apt-get install -y gcc g++ cmake zip

# Copy requirements.txt and install packages with appropriate CMAKE_ARGS
COPY requirements.txt .
RUN CMAKE_ARGS="-DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS" pip install --upgrade pip && pip install -r requirements.txt

# Stage 2: Final image using AWS Lambda Python image
FROM public.ecr.aws/lambda/python:3.12

# Install huggingface-cli and download the model
RUN pip install huggingface-hub && \
    mkdir model && \
    huggingface-cli download TheBloke/phi-2-GGUF phi-2.Q4_K_M.gguf --local-dir ./model --local-dir-use-symlinks False

# Copy installed packages from builder stage
COPY --from=builder /usr/local/lib/python3.12/site-packages/ /var/lang/lib/python3.12/site-packages/

# Copy lambda function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}

CMD [ "lambda_function.handler" ]

Let’s modify our lambda code to run LLM inference. Some more work is required to get the prompt out of the request body in the production environment.

import base64
import json
from llama_cpp import Llama

# Load the LLM, outside the handler so it persists between runs
llm = Llama(
    model_path="./model/phi-2.Q4_K_M.gguf", # change if different model
    n_ctx=2048, # context length
    n_threads=6,  # maximum in AWS Lambda
)

def handler(event, context):
    print("Event is:", event)
    print("Context is:", context)

        # Locally the body is not encoded, via lambda URL it is
    try:
        if event.get('isBase64Encoded', False):
            body = base64.b64decode(event['body']).decode('utf-8')
        else:
            body = event['body']

        body_json = json.loads(body)
        prompt = body_json["prompt"]
    except (KeyError, json.JSONDecodeError) as e:
        return {"statusCode": 400, "body": f"Error processing request: {str(e)}"}

    output = llm(
        f"Instruct: {prompt}\nOutput:",
        max_tokens=512, 
        echo=True,
    )

    return {
        "statusCode": 200,
        "body": json.dumps(output)
    }

OK, time to test! My docker setup has 8GB of RAM assigned, but it should run well under 4GB.

Let’s rebuild the container and start it again. It will take more time, as the model needs to download (~1.8GB).

docker-compose up --build

This time, let’s test with a real prompt. First run will take more time, as the model needs to load.

curl "http://localhost:9000/2015-03-31/functions/function/invocations" \
    -d '{ "body": "{ \"prompt\": \"Generate a good name for a bakery.\" }" }'

Example output:

Instruct: Generate a good name for a bakery.
Output: Sugar Rush Bakery.

{
  "prompt_tokens": 15,
  "completion_tokens": 6,
  "total_tokens": 21
}

Deploy to AWS Lambda

With everything working locally, let’s finally deploy our LLM to AWS!

To execute the deployment successfully, the following steps are required:

1. Initial Setup: Determine necessary information such as AWS region, ECR repository name, Docker platform, IAM policy file, and disable AWS CLI pager.

2. Verify AWS Configuration: Optionally confirm that the AWS CLI is correctly configured.

3. ECR (Elastic Container Registry) Repository Management:

   • Determine if the specified ECR repository already exists.

   • If absent, create a new ECR repository.

4. IAM Role Handling:

   • Check for the existence of a specific IAM role for Lambda.

   • If not found, establish the IAM role and apply the AWSLambdaBasicExecutionRole policy.

5. Docker-ECR Authentication: Securely log Docker into the ECR registry using the retrieved login credentials.

6. Docker Image Construction: Utilize Docker Compose to build the Docker image, specifying the desired platform.

7. ECR Image Tagging: Label the Docker image appropriately for ECR upload.

8. ECR Image Upload: Transfer the tagged Docker image to the ECR.

9. Acquire IAM Role ARN: Fetch the ARN linked to the specified IAM role.

10. Lambda Function Verification: Assess whether the Lambda function exists.

11. Lambda Function Configuration: Set parameters like timeout, memory allocation, and image URI for Lambda.

12. Lambda Function Deployment/Update:

    • For a new Lambda function, create it with defined settings and establish a public Function URL.

    • For an existing Lambda function, update its code using the new Docker image URI.

13. Function URL Retrieval: Obtain and display the Function URL of the Lambda function.

It is a simple but lengthy process to do manually, so I’ve created a script using AWS CLI. Feel free to modify the variables and run it yourself. The script is quite complex, you can do all the steps manually in the GUI if you want, apart from pushing the container.

If you are not doing this on M-series Mac, be sure to change linux/arm64 to linux/amd64.

#!/bin/bash

# Variables
AWS_REGION="eu-central-1"
ECR_REPO_NAME="llm-lambda"
IMAGE_TAG="latest"
LAMBDA_FUNCTION_NAME="llm-lambda"
LAMBDA_ROLE_NAME="llm-lambda-role" # Role name to create, not ARN
DOCKER_PLATFORM="linux/arm64" # Change as needed, e.g., linux/amd64
IAM_POLICY_FILE="trust-policy.json"
PAGER= # Disable pager for AWS CLI

# Authenticate with AWS
aws configure list # Optional, just to verify AWS CLI is configured

# Check if the ECR repository exists
REPO_EXISTS=$(aws ecr describe-repositories --repository-names $ECR_REPO_NAME --region $AWS_REGION 2>&1)

if [ $? -ne 0 ]; then
    echo "Repository does not exist. Creating repository: $ECR_REPO_NAME"
    # Create ECR repository
    aws ecr create-repository --repository-name $ECR_REPO_NAME --region $AWS_REGION
else
    echo "Repository $ECR_REPO_NAME already exists. Skipping creation."
fi

# Check if the Lambda IAM role exists
ROLE_EXISTS=$(aws iam get-role --role-name $LAMBDA_ROLE_NAME 2>&1)

if [ $? -ne 0 ]; then
    echo "IAM role does not exist. Creating role: $LAMBDA_ROLE_NAME"
    # Create IAM role for Lambda
    aws iam create-role --role-name $LAMBDA_ROLE_NAME --assume-role-policy-document file://$IAM_POLICY_FILE
    aws iam attach-role-policy --role-name $LAMBDA_ROLE_NAME --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
else
    echo "IAM role $LAMBDA_ROLE_NAME already exists. Skipping creation."
fi

# Get login command from ECR and execute it to authenticate Docker to the registry
aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query Account --output text).dkr.ecr.$AWS_REGION.amazonaws.com

# Build the Docker image using Docker Compose with specific platform
DOCKER_BUILDKIT=1 docker-compose build --build-arg BUILDPLATFORM=$DOCKER_PLATFORM

# Tag the Docker image for ECR
docker tag llm-lambda:latest $(aws sts get-caller-identity --query Account --output text).dkr.ecr.$AWS_REGION.amazonaws.com/$ECR_REPO_NAME:$IMAGE_TAG

# Push the Docker image to ECR
docker push $(aws sts get-caller-identity --query Account --output text).dkr.ecr.$AWS_REGION.amazonaws.com/$ECR_REPO_NAME:$IMAGE_TAG

# Get the IAM role ARN
LAMBDA_ROLE_ARN=$(aws iam get-role --role-name $LAMBDA_ROLE_NAME --query 'Role.Arn' --output text)

# Check if Lambda function exists
FUNCTION_EXISTS=$(aws lambda get-function --function-name $LAMBDA_FUNCTION_NAME --region $AWS_REGION 2>&1)

# Parameters for Lambda function
LAMBDA_TIMEOUT=300 # 5 minutes in seconds
LAMBDA_MEMORY_SIZE=10240 # Maximum memory size in MB
LAMBDA_IMAGE_URI=$(aws sts get-caller-identity --query Account --output text).dkr.ecr.$AWS_REGION.amazonaws.com/$ECR_REPO_NAME:$IMAGE_TAG

# Deploy or update the Lambda function
if echo $FUNCTION_EXISTS | grep -q "ResourceNotFoundException"; then
    echo "Creating new Lambda function: $LAMBDA_FUNCTION_NAME"
    aws lambda create-function --function-name $LAMBDA_FUNCTION_NAME \
        --region $AWS_REGION \
        --role $LAMBDA_ROLE_ARN \
        --timeout $LAMBDA_TIMEOUT \
        --memory-size $LAMBDA_MEMORY_SIZE \
        --package-type Image \
        --architectures arm64 \
        --code ImageUri=$LAMBDA_IMAGE_URI

    aws lambda create-function-url-config --function-name $LAMBDA_FUNCTION_NAME \
        --auth-type "NONE" --region $AWS_REGION

    # Add permission to allow public access to the Function URL
    aws lambda add-permission --function-name $LAMBDA_FUNCTION_NAME \
        --region $AWS_REGION \
        --statement-id "FunctionURLAllowPublicAccess" \
        --action "lambda:InvokeFunctionUrl" \
        --principal "*" \
        --function-url-auth-type "NONE"
else
    echo "Updating existing Lambda function: $LAMBDA_FUNCTION_NAME"
    aws lambda update-function-code --function-name $LAMBDA_FUNCTION_NAME \
        --region $AWS_REGION \
        --image-uri $LAMBDA_IMAGE_URI
fi

# Retrieve and print the Function URL
FUNCTION_URL=$(aws lambda get-function-url-config --region $AWS_REGION --function-name $LAMBDA_FUNCTION_NAME --query 'FunctionUrl' --output text)
echo "Lambda Function URL: $FUNCTION_URL"

Now, let’s add proper permissions and run the script.

chmod +x deploy.sh
./deploy.sh
# AWS_PROFILE=your_profile ./deploy.sh 
# if you want to use a different profile than default

As a result of the script, you should se the lambda function URL in your terminal. Let’s use it for a test.

PROMPT="Create five questions for a job interview for a senior python software engineer position."

curl $LAMBDA_URL -d "{ \"prompt\": \"$PROMPT\" }" \
    | jq -r '.choices[0].text, .usage'

Like before, the first run will take longer.

chmod +x test_remote.sh
LAMBDA_URL=your_url ./test_remote.sh

You should receive back an output similar to the one at the top of the article.

If you want to see the full project code, see github.

Performance

Cost and speed

You may have noticed that I chose to run the model under the configuration:

• 6 core multi-threading

• 10GB of RAM

• 5 minute timeout

How was the performance and how much RAM was used?

Lambda never reserves compute for you and sometimes loads your program “cold”. When you make a request, anything you need to load (like a model) needs to happen at this moment, we call this a cold start.

For the prompt about five interview questions, the execution time after cold start was 17 seconds which is not bad at all.

After that, it consistently took 9 seconds to generate an output, tested in 4 subsequent runs. The average output length was 83 tokens. So, we achieved ~9.2 tokens/second when running hot.

As a comparison, community reported speeds for OpenAI models are: GPT-4 10t/s, GPT-4-turbo 48t/s, GPT-3-turbo 50-100t/s. So we’re matching a decent but not industry leading speed with little effort.

You could run this prompt 4444 times in a free tier. Above that, it would cost $1.2 per 1000 runs. The same 1000 runs with GPT-3.5 turbo would cost $0.2. This makes this endeavour not really cost effective, so low cost shouldn’t be your aim if you’re going to implement this in production.

Optimisation

Could we run the model cheaper? The model uses under 2600MB of memory consistently. We could lower the allocated resources, with a caveat that 6 core CPU is assigned only to Lambdas above ~8846MB.

I ran first test at 3500MB (3 CPU cores / threads) to see how it compares. I didn’t change the code to run only 3 threads which had a downgrading effect. In this case, the lambda always timed out (ran over 5 minutes, which meant the request was cancelled).

After changing the number of threads to the proper 3, the execution almost timed out at cold start, returning results after 4 minutes and 33 seconds. Subsequent 3 runs took 26-40 seconds averaging 3.15 tokens/second. 1000 paid runs would cost $1.45. So we got slower and paid more, not a good optimisation! With this in mind, it makes sense to pay for more memory, because AWS assigns CPU resources proportionally to the reserved RAM amount.

Next steps

As you can see, running an open-source language model is possible even in a regular environment like AWS Lambda. Cost and quality of output is not matching industry-leading services but can serve as a use-case specific solution. If anything, this was a great opportunity to learn about basic LLM ecosystem libraries and tools as well as strengthen you AWS knowledge.

Some possible next steps, if you want to keep exploring and bringing this project closer to production-ready:

1. Try to run a different (bigger) model or a less compressed version of Microsoft Phi-2.

2. Create a CDK config to automatically deploy the model and create resources.

3. Create a GitHub Action to validate the project and run ./deploy.sh.

4. Try a different serverless platform to run the model.

5. Subscribe to my newsletter and follow me on social media.

I may write about some of these topics, let me know in the comment if you’re interested in any of them! If you bump into any issues let me know as well.

What do you think about this way of deploying LLMs?

More from me:

• Newsletter

• x/twitter: horosin_

• linkedin

Join me in this short recap if you want to learn where a path like mine can lead you. I’ll share mostly blog and online presence related details with some professional (engineering), financial and private information sprinkled on top. Happy to tell more to those interested.

Why am I here?

I like sharing knowledge, writing and helping people. I believe that publishing is a vital part of being a professional. Being here, rushing some content out even though it’s nor perfect, being vulnerable - that’s a great way to get to know more people and open one’s mind to new points of view.

I think one person - Austin Kleon - put this in words much better than me. Check out his short book and you’ll know everything.

Show Your Work! is about why generosity trumps genius. It's about getting findable, about using the network instead of wasting time "networking." It's not self-promotion, it's self-discovery--let others into your process, then let them steal from you.

I had a blast putting effort into this blog and other projects this year. Some people enjoyed it as well, as seen in stats from various platforms.

Stats

Here’s the most interesting numbers i dug out!

My blog was visited a total of 43 thousand times:

I also got additional 23k visits to my articles republished on Hackernoon.

My LinkedIn content generated 65k impressions, similar to views on the blog. I’ve been posting quite irregularly, as seen on the graph below. Near the end of the year, I’ve started listening to the numbers, resulting in more engagement than ever. Posts mentioning others and with my photos are noticeably more popular.

Other numbers:

• My newsletter got 50 subscribers (up from 24 in July).

• On twitter my posts generated ~300k impressions.

• I spoke at 8 conferences.

• I was a guest in 5 podcast episodes.

• I have published 12 blog articles.

Best content

If you missed some of my articles, here’s a chance to catch up. It’s clear that my most popular content was not opinions, summaries or anything related to my publishing online. Most viewed articles where software engineering tutorials. A lot of traffic came from google search, where I ranked quite high for some keywords. I also think I figured out a good way to create thumbnails.

11k views: Extracting and Generating JSON Data with GPTs, LangChain, and Node.js

9K views: How I Effortlessly Create PowerPoint Presentations with ChatGPT and MARP (as a Software Engineer)

2K views: Fine-tuning OpenAI GPT 3.5: Practical example with Python

Tip for me for the next year: write more engineering tutorials.

Other projects

• Real estate investing / buying a new apartment: simple message from me here: don’t build a house or buy a new unfinished apartment if you’re not really into it. I had to learn interior design from the ground up. Get to know materials, design solutions, too many new technical terms. It is interesting, it can be fun, but it is a lot of work. Even though I’m very happy with the outcome, I think I could have spent my time better.

• Side projects / startups: kicked off 2, shipped none. Excuses? Master thesis and moving apartments. Picking them up again in 2024. One was MeetingFusion: https://meetingfusion.com, the other is still unpublished. MF got several sign ups on the waiting list.

• My old AI Startup, Sentimatic: struggling, will post an update soon.

• Consulting: I’ve been able to provide some small-scale but well-paid software engineering services on the side.

• Funding for new AI project: applied for government funding, spent a lot of time. My assistant spent 175 hours on it! The application was of a master’s thesis size.

Opportunities

Writing here gave me more opportunities than ever before. Apart from everything mentioned above, here are some highlights.

• I’ve been invited few times to run a workshop about topics I write about by several engineering companies. All my offers were rejected due to the price. I am okay with this, as I only considered it if I was able to provide absolute best quality of the workshop.

• I’ve got more interesting job offers than ever. I did not proceed with any, as I’m committed to my current work at Netacea.

• I’ve been asked to develop a Vue.JS course for a popular course platform. The contract signing is in progress so hopefully next year some people will be able to learn something new using the course.

• I’ve been invited to many more conferences than I spoke at. Had to choose where to spend my time.

Money

My work around this blog and anything professional that is not related to Netacea (cybersec startup I’ve mentioned) only cost me money.

Apart from this money pit, I am quite okay at managing my finances, saving it and investing. I’m also fluent in tax codes, I don’t let money go to waste. I am following stock market to a limited extent as well. All of this pays dividends and helps me feel more secure in life. I recommend everyone to have basic financial fluency.

I won’t get into much detail and exact numbers, but I’ll share some stats to give you some insight into how I think about money and investing. I can share some guidelines for engineers in a separate article. Let me know.

My net worth (assets less liabilities) is allocated between cash, real estate and stocks. I am definitely real estate heavy but I have access to really good advice. Going forward, I’d prefer to have my net worth allocated in some business I run or contribute to in form of work or investment.

I am tracking my savings and investments as a whole by doing monthly net worth evaluation (it’s a quick exercise at this point). I’m doing it since April 2019 and have been able to maintain a good pace of growth, albeit with some ups and downs. Don’t get all excited, the starting point was fairly low!

My short advice for friends:

• use retirement tax advantaged accounts

• buy simplest stock market investments - index funds, S&P500, whole US stock market

• get a mortgage, it’s a low interest rate leveraged capital and overall properties keep up with inflation rates

• have a safety net by some small cash (as in bank) pile to bail you out in emergencies

Plans

My plans regarding this blog and my online presence are still in the making. I want to aim for something that will keep giving me satisfaction while being relevant and impactful. Here are the goals I am thinking about:

1. Launch and grow a newsletter up to at least a 1000 subscribers.

2. Shipping one successful SaaS tool on my own. And then grow or sell it.

3. Grow my global (online) and local (at Netacea) influence as an engineering leader.

4. Write 1 blog post per week.

5. Publish video content and get a reasonable following.

Regardless of details of these, you’ll likely see much more from me the next year! Stay tuned.

Summary

So yeah, a lot happened and I want it to continue to happen. This year has been another great period of my life which I’m truly grateful for. As for this blog, I want to keep writing and being a part of the global community.

After years of learning and working, I finally think like I have something to say. For me writing has always been this elusive thing that I never quite got to do. I stopped hiding behind perfectionism and started sharing. And many people found it useful, which just makes me happy. I keep learning but this time, I make some of my private notes public.

This year I’ve learned a lot, made mistakes, made new friends. The future looks exciting. See you there. Have the most wonderful year of your life.

More from me:

• Newsletter

• x/twitter: @horosin_

• linkedin

• threads: @horosin

Turns out the diplomatic community is really engaged in the topic of AI regulations, development and ethics.

We discussed topics including public diplomacy, cybersecurity, and AI in business development. It was cool to share my tech thoughts with some international politics enthusiasts.

We also tried to cover both opportunities and challenges AI solutions may pose in the future. I prepared a small summary of the main issues we talked through. I’ve learned a lot about diplomatic world, dive deep into this with me.

What is AI? Why the hype?

Why is there so much talk about AI now? The big moment happened in fall 2022 when ChatGPT came out. People started noticing AI more, but the tech had been around for a few years. What was missing was the right cloud infrastructure and servers, plus a good commercial product to sell.

Artificial Intelligence (AI) is commonly categorized into two types: narrow AI and general AI. Narrow AI, prevalent in today's market, excels in specific tasks such as language translation or image recognition but lacks the ability to operate beyond its programmed scope. On the other hand, general AI (or Artificial General Intelligence, AGI), a theoretical concept yet to be achieved, aspires to mimic human intelligence, demonstrating adaptability and learning across a wide array of domains. The development of AGI holds significant societal, ethical, and regulatory implications, prompting global discussions on how to manage its potential impact, including issues of privacy, safety, and ethical considerations. That said, until someone actually develops an AGI system, the topic is purely academic.

Currently in the AI field, two prominent types of neural networks are transformers and diffusers. Transformers excel in processing and understanding text, significantly enhancing how computers work with written information. Diffusers, meanwhile, creatively generate new content, like images or music, by progressively refining initial concepts. It is important to note that these technologies alone are unlikely to lead to the creation of AGI. Achieving AGI will likely require advancements beyond these current architectures.

What life areas does AI revolutionise?

I think that AI-related technologies are already making a break through in our industry, similar to how electricity transformed every aspect of our lives. AI has the potential to make significant changes in our personal lives, businesses, healthcare, and even military operations.

However, the scale and pace of AI development raises concerns about its potential harm if not properly regulated. AI is already revolutionizing tasks that are meticulous and repetitive, performing them better than humans. Instead of being a threat, I think it can be seen as useful in improving efficiency and productivity.

A major change in our civilization is coming up, and we can't accurately predict the extent of its impact on our lives. As AI continues to advance, we are entering an era of transformation and I’m curious to see what it will bring.

Some say that current text AI output is mediocre at best. I think that unremarkable skill applied at scale and at a whim can change the world.

Regulatory models and AI superpowers

Even though there is an already positive impact of AI tools on people's lives, they have been misused for among other misinformation and spam. There have been privacy concerns as well. This promoted certain regulators to take actions and start proposing targeted laws. What is more previous data protection laws still apply and influence AI models.

If we wanted to divide the way AI development is progressing and what attitude towards AI regulations is presented we can mention 3 models: American, Chinese and the EU one.

American

Currently, the USA stands as the leader in the AI market. The American perspective focuses on the prosperity of the tech industry through free-market policies for startups and businesses. There is also a preference for minimal government influence.

However, with the introduction of Chat GPT, there has been a shift in attitude. Now USA is trying to avoid consolidating too much power in a few big AI companies.

Despite those concerns, there is still a techno-optimistic attitude, assuming that companies will self-regulate (which might be a bit far-fetched). Just now new AI Bill of Rights including guidance on usage of AI has been unpacked, seen as the first step toward proper AI regulatory system.

Chinese

China's next-generation plan aims to position the country as a global AI leader, surpassing the USA. The primary goal is development. At first regulations were not present, allowing companies the freedom to pursue their initiatives with funding and access provided.

The concerns started with the rapid development of generative AI. Government got scared that AI may generate content outside the bounds of censorship.

There are now regulatory experiments to still support business development while making sure the advancements will align with the vision of the communist party.

EU

In the EU, we are now finalizing the AI Act - including the anthropocentric vision of AI with a focus on citizen laws and ethics. A key dilemma is how to strike a balance. How to keep startups innovative, ensuring technological independence, but also make sure citizens and their rights are safe.

Apart from mentioned models, there are of course also other countries/organizations that try to create independent laws within themselves.

Let’s take Israel - their Director General of Ministry of Defense announced plans to make Israel an AI superpower with a focus on military applications. They put a record-high budget for AI development with the focus on laws and research regarding defense needs.

Or recently France, Germany, and Italy agreeing on unified regulatory framework AI concerning companies in Europe. They don’t want sanctions on businesses to be immediate, rather put focus on incentives, and then later, if necessary, penalties for serious breaches.

Not long ago we also saw Italy was blocking ChatGPT being concerned with lack of proper processes regarding handling personal data processing and absent age restrictions.

There’s a multitude of solutions being discussed and implemented. Some try to regulate things that don’t exist yet (AGI). Some suggest putting restrictions that seem to benefit bigger players by raising the cost of operating AI systems.

I’m watching the space with moderate interest, as it can potentially affect me. That said, even if regulation will harm the innovation, it’s still more interesting to spend time on the actual tech, not the accompanying initiatives.

What regulatory issues I faced when running my own AI startup?

Machine learning model development depends on training data. When companies talk business, a lot of the time is spent discussing how to keep data safe and hand it over lawfully.

From what I've seen, China is tough when it comes to data safety. Everything has to get approved by the authorities, and the rules are strict. Because of this, many companies don't want to do business there (also political reasons).

The EU aims to keep its users' data within its own borders. Regulations say only the EU companies and EU citizens can process it. To put it in perspective, this is very similar to what China enforces.

Banks and financial institutions have the strictest rules. In many sales conversations I had for my AI projects, things came to halt when companies said they couldn't make data anonymous or didn't have good enough policies to share user data safely.

But this situation also creates a niche for products that work on premise. We can have an AI product that can run in client’s data center, and that opens up a lot of possibilities. This is the route I chose with Sentimatic.

Poland in AI development

I bring in my local perspective and a mix of opinions I've heard during the debate.

When it comes to EU laws, Poland plays a role in the establishment process, but simply because we're a member state, so we are sort of ‘forced’ to do so. For example, the recent EU AI Act involvement was a bit disappointing - only 12 people from our country participated, half from private companies, and the rest of them directly connected with Ministry of Digitization.

Polish citizens and companies aren't showing a strong interest in AI regulations. Our current attitude is that we're more on the receiving end than actively contributing. Additionally, Poland does not have enough strong AI startups. We are in danger of falling behind other European countries.

On a brighter note, there are some AI startups like Eleven Labs which are doing well. We do a lot of AI research, but turning it into something commercial is a challenge. There's money available for AI projects in places like PARP (government agency), but the paperwork required is massive, so you have to consider if you are down to take on a lot of bureaucratic risk.

I think that even though so far we've (as in Polish engineers) mostly worked for Western European and US companies, we've learned a lot. With a bit of optimism, we can use that experience and money to figure out how to build our AI scene. So surely, I’m curious of what’s coming. And happy to contribute.

What you should do to gain the most out of AI development?

With the rapid development of AI it is easy to miss out on different upcoming opportunities. Here is what I think is useful to think of to gain the most out of this technological breakthrough in the context of this debate:

Securing Funding:

• Explore private and government initiatives to fund your AI projects.

• Be mindful of the consequences of getting funding. As a specialist, you can bootstrap a small product as well.

Being Aware:

• Stay informed about new AI solutions, but avoid getting swept up in the hype.

• Keep an eye on government regulations that could impact your rights and business.

Looking for Job Opportunities:

• Look for emerging roles in the AI industry and find your niche.

• Use AI tools to streamline tasks, as companies are still trying to integrate AI.

Thinking of Privacy:

• Protect your data by applying privacy settings in AI chat applications. Pay for avoiding your data to be used for training.

Balancing Personalization and Automation:

• Use AI for content creation but not in a direct way. Be inspired. Get criticism. Always add value.

• Always check the quality and relevance of AI-generated content.

• Approach AI tools with caution, they make mistakes with striking confidence.

Conclusions

AI development is unavoidable. It is better to prepare ourselves for it rather than avoid the topic or threaten the society with a possible danger of new technologies. This technological revolution can be different than others, but fear mongers have been among us since the beginning of humanity. Sure, regulations are needed and we need to protect societies from AI-driven collapse but decisions should be evidence-based, not fear-driven.

From my personal perspective I hope to see Poland becoming more active in establishing AI laws and I'm closely watching any new regulations coming out which might affect me personally and professionally.

I think the best thing we can do right now is educate ourselves and try to gain the most out of the whole thing. It is silly to let some of the opportunities pass us by and not use the whole potential (generative) AI has to offer.

Your thoughts? More worried or excited? Regulation: BS or necessity?

• Newsletter

• x/twitter: @horosin_

• linkedin

• threads: @horosin

All week, I had suspected something was wrong with my apartment. The smart switch controlling the water supply seemed dimmed as if it was off, even though it was allowing the water to flow.

Simultaneously, I started hearing more about ghosts. My coworker had signed up for a New Year's Eve party at an abandoned psychiatric hospital involving Ouija boards. Inspired by this, my girlfriend and I spent hours discussing the existence of unseen forces around us.

Imagine our despair when, on Friday night, our electrical box began making cracking noises, and our lights started flickering on and off. The water supply was being cut, disrupting the washing machine and dishwasher. I suspected the smart home relay, installed by the building developer, was the culprit. Exhausted and clueless, I couldn't fix it. There was no "off" switch, so the disturbances continued sporadically throughout the night.

We woke up tired, angry, and slightly creeped out.

The next day, I tried to resolve the issue. I hit the reset button repeatedly and looked for a "bypass" switch, but nothing worked. The problem persisted, albeit less frequent. The relay had never been configured because as it’s a new apartment I didn't have a Wi-Fi router yet, and frankly, I hadn't been interested in it before. I attempted to configure several times it using my girlfriend's phone as a router to follow the official guide, but to no avail.

In the end, I decided to go primal. My girlfriend and I scoured online manuals for different parts of the electrical box. We discovered a pin that could lock the digital switch for electricity in the always-on position. There wasn't one for the water, but fortunately, the smart home hub had mixed up the off/on states...

In our final test, I turned the smart home relay switch off. Previously, this action would cut off everything, but now it had no effect. The monster was defeated.

This experience got me thinking. If there's a lesson to be learned, it's the importance of having an "off" switch on every device.

I hope this ordeal isn't a prelude to a future dominated by AI overlords. Imagine if my building developer were a company like Microsoft/OpenAI, the smart home hub a deeply integrated AI model in our lives, and I, an oblivious user. A sleepless night could symbolize a future where we have no control over what's happening.

Perhaps I'm taking this too far, but I need sleep. Take care, everyone, and may your smart devices spare your sleep. Were you ever attacked like this?

• Newsletter

• x/twitter: @horosin_

• linkedin

• threads: @horosin

I first thought about speaking at tech conferences as a way to get a free ticket – let's face it, they're not cheap. But what started as a practical move turned out to be a journey of incredible learning and networking. Over time, as I spoke at more than 19 events, I realized these conferences were more than just stages to share ideas; they were opportunities to connect with CEOs, top experts, authors, and so many inspiring people.

Back then, my experience included only teaching JavaScript to my colleagues at work and presenting startup ideas at local hackathons. These experiences were my stepping stones into the world of tech conferences. Today, with a wealth of presentations behind me, I want to share why stepping onto that stage is so rewarding. It's not just about discussing cutting-edge topics like programming techniques, AI advancements, boosting productivity, or nurturing startup growth. It's about the interactions, the shared knowledge, and the diverse perspectives you encounter. In this guide, I'll take you through how to kickstart your journey in conference speaking and make the most of it.

Advantages of becoming a conference speaker

• TOP ONE: opportunity to meet new people from your field; share what you're working on and get inspiration for new projects. Listen to other speakers who are way better than you in engineering. I’ve met notable figures in engineering through conferences and had a chance to ask them questions about how they work or run their companies. I know I wouldn’t have a chance of meeting them anywhere else.

• Getting valuable credentials; speaking at conferences provides you an opportunity to present your expertise, skills, and background, potentially strengthening your current job position and boosting credibility with both existing and potential clients. Your presentation typically undergoes a selection process conducted by an experienced panel of professionals on the program committee, so you get the chance to see if there's any audience for your knowledge. From my experience, when applying for jobs, interviewers really appreciate some background connected with public speaking. And finally, once you become more recognizable, further speaking opportunities are unlocked and organizers start to reach out to you themselves.

• Collaborating; participating in a conference is a good way to meet and run your ideas through experts. Or expand your professional network if you're into LinkedIn lingo. You can (and I recommend doing so) engage with other speakers, event coordinators, and sponsors. This may lead to potential collaborations and career opportunities. Sharing your contact information for future communication is a must. After some of the conferences I got offers to run thematic courses in some companies, so once the market sees you as an expert in the field, you can really expand your brand.

• Reinforcing your skills; when preparing your presentation, you have the chance to structure your know-how in an organized and effective way. Additionally, while presenting your talk, you practice the delivery of your hard-earned knowledge and you get a chance to be challenged by participants’ questions related to your topic. Preparing presentations helped me look critically at my work and improve how I do things.

• Expanding your online presence; you can distribute your presentation slides to the audience through social media, post your talk video on platforms like YouTube, or interact with individuals involved in the event through LinkedIn and other platforms. I also noticed that even though I never promoted a product, a book, or anything in particular, there were always some new followers or contacts on all my platforms.

How to find conferences to participate in?

To find the top events to speak at, I do a brief scheduled conference research every two weeks. I search for IT conferences that match my area of expertise and check if they're accepting talk proposals.

For international conferences, having a speaker profile on a platform like https://sessionize.com/ is the best way to discover new, interesting events.

I also recommend checking out the following websites:

• https://dev.events/tech

• https://www.eventyco.com/events/conferences/tech

• https://confs.tech/

I am based in Poland, Europe, so I also look at local events and my go-to place is Crossweb. Every country will likely have an event aggregator like that.

At this point I also get directly invited by past event’ organizers I spoke at or by conference managers who saw me on other event's websites.

Once I find a conference I like, I either apply right away (if I have a suitable talk ready or in the pipeline) or I set a deadline for myself in Notion (note-taking/project management app) to create a proposal.

To keep track of all this, I've made a special section in notes for conference applications. It helps me see which events I've applied to, whether the organizers accepted my proposal (or not), and the topic of the talk I submitted. When you take part in conferences regularly, it's easy to get lost in all application forms and emails, so this system keeps everything organized and makes sure I don't forget or miss out on opportunities.

What you can prepare prior to applying?

To make applying for conferences easier and faster, I organize important information in one place. This way, I can quickly access it whenever I need it. For each conference application, you usually need to provide:

• Basic data; your email, phone number, Twitter and LinkedIn handles, a profile picture, your current job title, and a short bio. I have all this information saved in a dedicated section in Notion, and just copy paste it when I apply for a conference.

• The bio; you provide should include details about your current job, any extra projects you're involved in, and fields of expertise you feel confident about and can present at the conferences. As an example, here's my latest bio for reference:

  Software Engineer Manager at Netacea, an AI cybersecurity SaaS startup based in the UK. Creator of sentimatic.io - a product for analyzing emotions and content of customer conversations based on AI technology. I run a blog on horosin.com, where I write about topics related to programming, AI products, and startups. I am professionally and personally interested in biotechnology, medicine, space technologies, filmmaking, and literature. I enjoy sharing knowledge in the field of programming and AI-based solutions while gaining inspiration from discussions with new people I meet.

• Overview of the talk you want to present; I keep track of all my talks and ideas in Notion, so if I'm short of inspiration, I simply update it and add necessary changes, instead of starting from scratch every time.

• Past conference experience; I keep a record of my public appearances on my blog at https://horosin.com/conference, and I always link it as a part of my application. It's important to have a portfolio that shows your experience, as it makes you a more reliable candidate. Here's a note I attach:

  I have spoken at several conferences so far. I like talking about programming, startups, innovative products and advancements in the AI field. Here is a link to all my conference experiences gathered:

  https://horosin.com/conference

  I have also been on the program board of a 2021 4developers Live conference. I was responsible for the selection of talks for the Python track.

How to prepare and present a talk?

Successful conference participation depends mostly on what and how you present. Take the time to establish your personal strengths, define what you’re good at, and narrow down your field of expertise. Find something in your work that is valuable to share with your audience and make sure the content is genuinely useful to your listeners.

Remember that talking about your mistakes can be as beneficial as celebrating your successes. Consider your failures as lessons that can prevent others from making similar mistakes. I've done this numerous times, for example, while discussing the five startups I failed at. I talked about this at three different conferences, sharing my business journey and what I learnt from it https://horosin.com/i-launched-6-startups-in-8-months-and-5-of-them-failed. It is to this day one of my most popular talks and blog articles.

While preparing the slides, I follow a process:

1. Craft an outline for your speech.

2. Draft your initial version.

3. Refine your draft, brainstorm fresh ways to share your ideas, and then settle on the final version.

4. Create slides for your presentation.

5. Improve your presentation with engaging elements such as data, graphics, personal anecdotes, or connections to certain individuals to make it stand out.

Remember to practice your speech, watch your timing, and make adjustments as necessary to fit the given time frame.

During your presentation, don’t forget about a few key tips while still trying to stay natural. It's not necessary for everything to go according to the script, however, small adjustments can improve the final result:

• Body language: Try to pay attention to how you move. Use your body to show your ideas and to better connect with your audience. Move around the stage, keep eye contact with various listeners and use hand gestures or facial expressions to underline some main points.

• Focus on your personal expertise: Your main goal should be to provide value to the audience, not to sell products. If you give people what they came for, they'll want more from you. You just need to tell them how to find it. I put my social media information on my presentation’s slides and sometimes at the end of the talk, depending on the conference, share new product ideas connected with the speech.

• Get the audience involved: Keep the conversation going. Plan a time for questions and answers with the listeners. This part can help you look at your material from different perspectives. You can get authentic feedback on your work.

• Ask for feedback: Don't forget to ask for thoughts and suggestions. It can help you get better for your next talk and develop your portfolio. At some conferences, feedback is collected through forms and later visible in your speaker’s profile. Otherwise, simply collect it by directly sharing feedback forms.

While presenting, never downplay yourself. If you were selected to speak, then your expertise is enough. You also put your name and time on the line. We're all busy and trying the best we can. If you "had no time to make the slides pretty", don't say that, it's annoying to people that give you their attention. Just pretend your lack of design polish is just your cute nerdiness. Much better effect. Or better just have a look at my article about MARP so your slides are never ugly again and take 10x less effort: https://horosin.com/effortlessly-create-powerpoint-presentations-with-chatgpt-and-marp

How to get the most out of conferences (before and after)?

OK, you got an acceptance email and now what? If you want to get the most out of the conference, it's important to plan ahead. Here's a simple guide on what to do after being selected as a speaker. It's a process I loosely follow. If you do any of the steps, you're already ahead.

All that said, the key is a great submission and a value-packed presentation. Everything below is pointless without those.

• 3 weeks before the conference

Start researching the people involved, like the event organizers, other speakers, and sponsors. Identify those you'd like to connect with and reach out to them online. Contact them to schedule a meeting or chat before the event.

• 2.5 weeks before the conference

Share any promotional graphics the organizers provide, which usually feature your photo, topic, track, and maybe a discount code. Publish content on your social media and tag people involved. You can also create your own announcement post if needed.

• 2 weeks before the conference

Consider talking to the organizers about creating a post for their social media. This could be a video inviting others to the conference or a short post about your talk.

• 1.5 weeks before the conference

Create a teaser post with a summary and key points from your presentation to generate more interest. This is a good way to share some knowledge online in preparation for the event. Provide real value, don't advertise.

• 1 week before the conference

Make sure your presentation is well-prepared. Upload your slides online so you can easily share them with participants after your talk. Also, direct people to your social media for any updates.

On the day of the conference, connect with as many people as you can, especially those you researched earlier. Attend other talks, take notes, and share your thoughts about them on social media. Take photos during other speakers' presentations and share them later to provide fresh content for their social media. Engage with your audience after your presentation, perhaps over a coffee. Respond to social media posts related to the conference and share your behind-the-scenes impressions.

Now that the conference is over, expanding your network and benefiting from participating doesn't really stop. Here are some things that I do afterwards.

• 1 Day After the Conference: Share Your Thoughts

After the event, post your impressions on social media. Share what you learned and your general thoughts on the conference. Tag people to start discussions.

Here is an example of my LinkedIn post, which I published after speaking at Devoxx Poland:

As you see it was quite successful - got 52 likes with only 500 followers I had at a time.

• 2 Days After the Conference: Update Your Portfolio

Add the conference experience to your speaker portfolio. This could be a website, LinkedIn article, your resume, or wherever you gather your accomplishments. Keep a list of the talks you've given, including dates, titles, and event names. It's a good place to share notes, slides, and related materials from your talks.

• 5 Days After the Conference: Share Your Presentation Materials

Share the slides you used in your presentation. You can post the original materials or create a quick guide on the topic you presented. Sharing knowledge is one of the key points of being a conference speaker, so I try to come forward to my listeners with as many useful sources as possible.

• 10 days After the Conference: Gather Feedback

Collect feedback from the audience and organizers. You can use social media polls, direct messages, or check for opinions on your speaker profile. Reading feedback helps you find areas for improvement and can be useful for future conference applications or negotiations regarding payment.

• 2 Weeks After the Conference: Reuse Your Content

You can reuse your slides by turning them into articles, posts or applying feedback and refining them for another conference. I post articles related to my talks on my blog so they're always available for reference.

Money. How much does it cost? Can you get paid?

Usually, the conference will cover all your travel expenses and admission. You will also get invited to speaker dinners and extra networking opportunities. Some events may ask if you have an option to pay for travel yourself or ask your employer for coverage, it will raise your odds of being admitted.

My experience with travelling for conferences is mixed. Some booked very low quality, scary even, accommodation. These events are often sponsored by big companies and generate a lot of profit. Saving on speakers feels unacceptable to me, as they usually contribute to the event's success for free.

I lived abroad for some time and a few conferences paid for my flights back home in order to speak.

Getting paid? If you have a lot of experience, are an established author, and work in a great company - yeah, possible. Usually, a good conference will pay a few speakers, especially the keynote ones. Many, even very experienced ones, will just get their expenses covered but it's a welcome enough benefit for them and should be for you. Speaking is often a community contribution, a way of giving back to the community.

Do you have to take time off to speak at a conference? My arrangement is usually to present as a part of my job. The company I work with always gets mentioned, I try to generate sales leads and do a bit of hiring at every event I attend. I also provide photos and short written reports for the marketing department so they can prepare some content for the company's social media channels. Don’t be afraid to talk to your manager to work out the details. You being at a conference as a speaker is a pure benefit for the company - you get free training and generate free publicity. Make sure it is well understood.

I’m also spending a bit of my own money on the whole process. I work with a part-time personal assistant who helps me, among others, with managing talk submissions and refining slides from the design point of view.

Conclusions

Summing up, I recommend taking part in conferences as a speaker. You get the opportunity to expand your network, organize knowledge and practice public speaking.

Making conference research a part of your regular tasks will result in more event opportunities, I did so and the number of conferences I took part in 2023 is higher than ever before.

If you prepare for your speech in a smart way you can reuse your content.

Following a few simple steps before and after the conference will help you make the most out of your presentation and will result in the development of your personal brand.

For the next year, my plan would be to speak mostly at international events so I can mix it with some travelling. I'm also aiming to get some number of paid gigs, as I have plenty of experience to do a solid agenda-boosting keynote.

Do you plan to speak at any tech conference? Any stories or thoughts?

Reach out to me if you need any help and follow my newsletter and social media accounts for more stories from the software engineering trenches.

• Newsletter

• x/twitter: @horosin_

• linkedin

• threads: @horosin

We often try to live up to our job position titles. From my experience, you can find yourself in two difficult situations. In one scenario, you might feel underqualified for your position, constantly chasing perfection without ever feeling satisfied. In contrast, you may feel constrained by your job title, which keeps you from exploring other areas of interest.

Here’s my advice in one sentence: do “you”, create a unique mix of skills amplifying your talents, and become irreplaceable by raising your value regardless of what the current title says. Exceed expectations. But make sure you're looking at the right ones.

Let me tell you a story. I trained Judo (a Japanese martial art focused on using an opponent’s strength against them) for years. When I competed in tournaments, I was always wearing the most beginner belt colours. My coach never provided us with many options to get certified and pass exams. I felt I was worse than my competitors. I told him I wanted to pass the blue and brown belts (just one step before black) exams.

He told me I could wear them, that I could wear whatever I want really and he’ll have my back. He said that I would have easily passed the exams years ago and it’s not important what colour I wear but how I fight. He asked me how many times I beat brown and black belts. The answer was plenty enough.

I think about this conversation every time I feel like my job title doesn’t describe what I do (or want to do).

I’ve been influencing how software is built in companies while working at every level of my career, even as a junior software engineer. I trained people, proposed interview questions, built templates, and provided advice. The position titles came afterwards. They always came. Perhaps I was lucky to work with leaders that noticed. Now I try to be the one.

“Don’t give any of yourself away” is the quote I remember from excellent Austin Kleon’s books. Don’t drop your hobbies. Nurture small things you like. Apart from coding, do you like cooking, designing, painting, parenting, running, whatever else? Keep it as a part of you. You don’t need laser focus, you’re much better off being an interesting diverse individual that created their own path.

You still need to be great at something, don’t get me wrong. While there are already great engineers, artists, and data analysts, none of them have your unique perspective… Unless you’ve abandoned your uniqueness.

Don’t feel you’ve ever had the ingredients for your perfect mix? Go out, experience new things. Contact distant friends that you see doing cool stuff on Instagram.

When I was younger I felt terrible not feeling an expert at one thing. I felt I’m wasting time filmmaking or writing short stories instead of coding. I envied people who seemed so focused and were high achievers. But most of them created their own paths. And their perceived focus was often just a result of good branding.

Look at Tim Cook. At first, everyone compared him to Steve Jobs. Now he gets his own biographies. His Apple is different, yet it still flourishes. He didn’t imitate Jobs, he became his own flavour of Apple CEO. Now many want to be Tim, less erratic, better at working with people, persistent over time.

My writing skills and a gut for good image composition prove useful every day. I can edit promo videos. I can write okay product copy. I can contribute to UX designs. My hobbies and interests feed my work indirectly and are to my advantage.

In my recent podcast appearance, I discussed the cybersecurity challenges associated with handling genetic testing data. I realize that not many individuals have experience in both biotech and cybersecurity, which makes this conversation somewhat unique.

You do you. Embrace your uniqueness and respect the uniqueness of others as well. All parts of you are valuable. Find places where you can utilise this potential. Don’t give any of yourself away.