Forem: Antonio Sánchez

KasusKnacker: Building and Shipping a German Practice App with AI

Antonio Sánchez — Mon, 02 Feb 2026 17:34:47 +0000

TL;DR: I built an app for practicing German called KasusKnacker, available on Web, iOS and Android. What’s interesting isn’t the app, but the process: I built the entire product mostly with AI, including software, learning content generation, translations, copywriting, and visual assets. AI made it possible to create ~30,000 exercises with explanations/translations in a few hours for under 150€ (including QA passes). It also drastically reduced the time to prototype and ship multi-platform features. However, AI is not a magic bullet: it tends to generate duplicated code, fragile architecture, and naïve implementations around security and costs. In Firebase-style stacks, this can easily translate into real billing risk. AI multiplies productivity — and mistakes. Human review is not optional.

I previously wrote about AI-assisted coding in AI in Coding: My Two Cents. This post is the practical follow-up: building and shipping a real product mostly with AI tools, and what worked vs. what didn’t. It’s basically my “what actually happened” log.

KasusKnacker is a German practice app. It focuses on the grammar gaps many expats keep for years (der/die/das, cases, prepositions, conjugation), and it also includes flashcards for vocabulary and idioms.

I originally built it as a hobby project for myself. I’m Spanish, I’ve lived in Germany for over 12 years, and since I never formally studied German, I still hit the same grammar potholes. The app is basically training for exactly that.

But I also used the app as an experiment: could I build an entire product end-to-end using AI, not only for coding, but for everything else that usually blocks solo projects (content, translations, design assets, marketing copy, etc.)? I wanted a real answer, not a demo.

My AI Tool Usage

For coding, I used a mix of Antigravity (Gemini 3 Flash and Gemini 3 Pro), Claude Code (Opus 4.5) and Codex (GPT-5.2). I’d usually ask two models the same question and see where they disagreed.

For generating exercises and translations, I used Gemini 3 Flash and Gemini 3 Pro.

For app and website copy, I used GPT-5.2.

For images (logo, avatars and social media visuals), I used nano banana.

My workflow was to run multiple models for the same task and compare results. This is especially useful for higher-level code changes (architecture, refactoring, SDK usage), where models often disagree. When they disagree, it’s a signal that the task has complexity that deserves careful review.

What I’ve Learned

Software development has already changed

I don’t know if AGI will come soon or not. The label is not important.

What matters is that for software development, the paradigm already changed. For an experienced developer (especially someone used to working across dev + ops), AI tools drastically reduce the time required to build and ship products. I felt that shift almost immediately.

Not by replacing engineering, but by compressing the execution layer: writing boilerplate, generating repetitive code, composing UI pieces, writing tests, producing documentation, etc.

But the real effect is scope. A solo developer can now deliver projects that used to require a team, mainly because the AI tools reduce friction across multiple disciplines (coding, content, design, copywriting). That’s the part that still surprises me.

The biggest impact wasn’t coding. It was content.

For educational apps, content generation is the real bottleneck. The code is the easy part.

KasusKnacker includes roughly 30,000 exercises, each with translations and explanations. Without AI, producing that amount of content would have been unrealistic for a solo developer. It would require either a long timeline or a paid team (and still plenty of QA work).

With AI, it became an engineering process: define a schema, generate in batches, validate automatically, then apply QA passes.

I generated the entire set in a few hours for under 150€ including QA passes. That number felt unreal when I saw the final bill.

That was the first moment I felt AI doesn’t just make you faster. It changes what is possible.

AI removed most of the design bottleneck

Design and assets are another classic blocker for solo apps. You can ship functional software, but without coherent visuals it will look unfinished.

Without AI, I would have needed a designer for logo, avatars, and a lot of visual content used across the app, website and social media. With AI, I produced enough assets to ship a coherent product. Some of them I iterated on for days, but at least I could iterate at all.

No, it’s not a substitute for good professional design. But it’s sufficient for shipping a real app.

AI productivity is real, but quality control is mandatory

AI makes you more productive, but it is not a magic tool. It definitely fooled me a couple of times.

It generates a lot of code quickly, but it also generates duplicated implementations, wrong assumptions, weak error handling, unnecessary complexity, and subtle bugs that are easy to miss.

Even if your prompts are good.

It is also common for AI-generated code to work while still being structurally wrong: mixing SDKs, bypassing best practices, or creating a fragile architecture that becomes hard to maintain. I saw this happen more than once.

AI is good at execution, not at engineering judgment. You still need to review, refactor, and simplify.

Key Limitations (Real Examples)

1. AI-generated content still needs QA

Around 2% of generated exercises contained actual errors (wrong answer, wrong translation, wrong explanation). That’s not huge, but with 30,000 items it becomes a lot of broken content.

More importantly, around 18% of exercises needed improvements. Not because they were objectively wrong, but because they were not aligned with the intended level/topic. Common issues were overly long questions, ambiguity (multiple answers could be correct), unnecessary complexity, or translations that were technically correct but confusing.

This is where most AI content generation projects fail. Generating content is easy. Generating good content at scale is not.

My solution was to use AI against itself: run review passes that validate the content and request corrections. This improved quality massively, and reduced the amount of manual cleanup needed. It also made the remaining fixes feel manageable.

2. Context handling issues lead to duplication and fragile codebases

The app went from idea to working product very quickly. Multi-platform support (web + native) was not a big problem.

But despite good prompting, AI still tends to introduce duplication and architectural drift. It frequently forgets existing abstractions and re-implements things. It also tends to patch forward: if something fails, it adds another layer rather than simplifying the original code.

A concrete example: mixing approaches between Firebase web SDK and the Capacitor-native SDK for auth. It can be made to work, but the result becomes fragile and hard to reason about. I ended up standardizing just to keep my sanity.

So after the first “it works” stage, you should expect a deliberate cleanup stage: consolidating duplicated code, removing incorrect approaches, enforcing one architecture, and adding error handling.

3. Security and costs are the most dangerous blind spots

For real products, this is the most important limitation.

AI tends to generate naïve implementations around security boundaries and abuse scenarios. It can generate code that works perfectly and at the same time creates billing risks, privilege escalation paths, or insecure data flows. This is the part that worried me most.

In Firebase-style architectures, abuse becomes billing. If your database rules and backend architecture are not designed with abuse in mind, vibe coding can literally become expensive.

During review I found and fixed multiple risk patterns: inefficient backend usage, possible billing attacks against Firestore/Functions, and client-side logic that should never be trusted (e.g. users being able to modify critical fields such as premium subscription state).

After manually reviewing and optimizing the architecture, I reduced projected hosting costs by roughly 95%. Not because I changed infrastructure, but because the initial AI-generated approach was inefficient and too permissive. That was an expensive lesson I got to avoid.

This is a strong warning for anyone shipping AI-generated production systems: if you don’t understand your stack deeply, AI will happily generate something that becomes a future liability.

How to Use AI Effectively (My Current Process)

AI works best when the developer acts as an architect.

The model should not be the driver. It should be the execution engine. Your job is to define the structure, constraints, and quality bar.

In practice that means you break work into smaller tasks, you provide explicit constraints (stack, libraries, patterns), and you review every output critically. I treat it like delegating to a smart but rushed teammate.

You should treat AI output like code written by a junior developer: it can be useful, but it must be checked, simplified, and tested.

And importantly: when building production systems, always consider security and billing early. AI will not protect you there. If anything, it increases your exposure because it makes it so easy to ship quickly without thinking about abuse scenarios.

Synthetic Product Data Generator

Antonio Sánchez — Sun, 24 Mar 2024 18:49:12 +0000

Today, I'm sharing a new project: a Jupyter Notebook for synthetic product data generation using Large Language Models (LLMs) through the LangChain framework. This tool is designed to aid in the creation of synthetic yet realistic product listings for e-commerce and other domains.

What It Does

The notebook facilitates the generation of synthetic data, including vendor names, product categories, and detailed product information such as titles, descriptions, and prices. It is built with flexibility in mind, allowing for the integration of different LLMs and customization of data generation parameters to suit various needs.

Features:

Integration with multiple LLMs, including examples for Ollama and OpenAI.
Customizable data generation to adjust shop type, categories, vendors, and product details.
Interactive environment for real-time monitoring and adjustments.

Why I Started This Project

I started working on this project because I'm really interested in a few key areas:

Exploration of LangChain

The main reason I began this project was to gain more hands-on experience with the LangChain framework. I was curious to see not only how it operates but what possibilities it unlocks when integrated with various LLMs.

Prompt Engineering

Another important part of this project is learning how to make good prompts. Figuring out the right way to ask questions or give commands to LLMs can really change the results you get. This project is like a testing ground where I try out different kinds of prompts to see how small changes can make a big difference in what kind of information or data we can generate.

I quickly found out the trickiest part was getting the prompts just right. It’s amazing how a single word change can totally switch up the results, especially with the smaller LLMs. This part of the project was where I spent most of my time, going through many iterations to get it perfect

Creating Synthetic Data

A big part of why I'm doing this is to have a tool that lets me easily create customized synthetic data for some others of machine learning and retrieval-augmented generation (RAG) projects I'm working on. Having the ability to produce realistic yet artificial data means I can test, develop, and analyze different projects more effectively.

Crafting My Own Tools

So, why didn't I just use some tool that's already out there? Because building my own would is more fun and a great way to practics. Plus, I wanted something that fit exactly what I needed, which I couldn't really find with the tools available.

This notebook is a practical tool that embodies these motivations. It demonstrates the power of combining custom prompts with different LLMs to produce synthetic data that is not only diverse but also closely tailored to specific project requirements.

Getting Started

For those interested in using or contributing to this project, the notebook is available on my GitHub repository. Installation instructions and details on how to customize and run the notebook are provided in the README. The project also supports running in Google Colab for ease of access and use.

Dependencies can be installed via pip, and the project is ready to run in a local environment or in Google Colab with minimal setup.

Join the Effort

I welcome contributions and ideas to enhance this tool. Whether you have suggestions for new features or improvements, feel free to reach out through GitHub.

Relaunching after Pivoting

Antonio Sánchez — Thu, 20 Jan 2022 11:00:10 +0000

On March 2021, and after almost two years of development, I launched found.dev. I had a lot of expectations on it, but as it happens with most of the new launches, it was a complete failure.

Even though the software was working good and had enough features, it seemed like absolutely no one had any kind of interest in the product, at all. After several months of trying different approaches on how to get users to try and use the product, I gave up.

I didn't work on the project for a few months and stopped to think about all errors I had done: no marketing plan at all, no clear roadmap, diffuse sales pitch, etc... The product was, in my opinion, good, but I just didn't know how to sell it. Or worse, the product was good, but no one needed it.

In December 2021, I decided to take on the project again and completely transform it into a new thing. Something way simpler, based on the feedback I got from my first try: a job board. But not a normal job board like the other thousands of job boards out there, based on a specific language, framework, or tool, but a job board for having them all!

Today, after a few weeks of work, I have completely remade the product and I have just launched it on Product Hunt: https://www.producthunt.com/posts/found-dev-2-0

I would appreciate any feedback :)

Download a copy of an entire website

Antonio Sánchez — Sat, 11 Dec 2021 19:08:36 +0000

I have created a simple yet powerful command-line application to easily download an entire copy of any online website.

It is coded with Go and it is available on my GitHub: https://github.com/antsanchez/go-download-web

I normally use it to:

Back up any website (at least the rendered part of the website)
Create copies of websites for accessing them offline

It also allows you to change the URL of the downloaded website, which can be very helpful when moving an existing static website from a domain to another.

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

If you need any help or have any questions, do not hesitate to contact me.

Deploy a Go API to AWS Lambda and API Gateway

Antonio Sánchez — Sun, 07 Nov 2021 20:51:17 +0000

In this article, I am going to describe the process of deploying an API coded with Go to AWS Lambda and Amazon API Gateway, a process that takes only a few minutes if you know how to do it.

We will see how easy it is to deploy a Lambda function and validate requests and API keys via the API Gateway.

I will assume that you have a basic knowledge of Go and an AWS account. If you don’t know anything about AWS Lambda and API Gateway, don’t worry, all you need to know is explained here. If you already have a good knowledge of Lambda and API Gateway, feel free to skip some of the explanations.

Create a Lambda function using Go

As you probably know already, with AWS Lambda you can “run code without provisioning or managing infrastructure. Simply write and upload code as a .zip file or container image.”

Creating a Lambda function is pretty easy. You need some code and a Lambda function where to upload it. We will start with the code.

All you need to know is that you need to import github.com/aws/aws-lambda-go/lambda and create a “handler”. There is already a very good explanagion about which arguments can this function take, so it is not worth repeating it:
https://docs.aws.amazon.com/lambda/latest/dg/golang-handler.html

Let’s create a very simple function that will only get a team name and an array with the members, and return the name of the team and the number of members. You can find the code here: https://github.com/antsanchez/go-lambda-apigateway-example

package main

import (
    "github.com/aws/aws-lambda-go/lambda"
)

type TeamRequest struct {
    Name    string   `json:"name"`
    Members []string `json:"members"`
}

type Response struct {
    Name         string `json:"name"`
    MembersCount int    `json:"members_count"`
}

func GetTeamAndMembers(req TeamRequest) (Response, error) {
    return Response{
        Name:         req.Name,
        MembersCount: len(req.Members),
    }, nil
}

func main() {
    lambda.Start(GetTeamAndMembers)
}

Once the function has been created, you have to compile the code and create a ZIP for uploading it to AWS Lambda:

$ GOOS=linux go build main.go
% zip function.zip main

Now let’s go to the AWS console, search for Lambda, and click on create a new function. Pick whatever name you like, select Go, leave the rest as it is for now and click on create.

In the next screen, make sure to change the handler to “main”, as on the following screenshot:

Now upload the ZIP folder and that’s it, your function is ready to use! Before switching to API Gateway, let’s test it. Go to the “Test” tab and create a request, like this:

You should see this response:

{
  "name": "Example Team",
  "members_count": 3,
}

Create the API Gateway trigger for the Lambda function

Ok, the Lambda function exists now, but how can you access it? We need to create a trigger, in this case, an API Gateway trigger. This is going to create an API Endpoint for us that we can use to call our Lambda function.

Click on Add Trigger:

Then select API Gateway, REST API as an API type, “Open” as a security mechanism for now, and hit on “add”.
Our screens should now look like this, and there it is our API Endpoint.

Validate JSON Request with API Gateway

We can validate the request before it even hits our Lambda function thanks to API Gateway. Like this, we will save some money by not executing the function on bad requests.

Click on the link to the API Gateway (not the API Endpoint) to open the settings of our Gateway, you will see something like this:

Now click on Models and “create”. Here, we can add a JSON Schema to describe how the request should be done. Going in deep about how to define the JSON Schema and its possibilities is out of the scope of this tutorial, but you can find more documentation here: http://json-schema.org/ All you need to know for now is that you need to define the schema of the request like this:

{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "title": "Team",
    "description": "Team and members request",
    "type": "object",
    "properties": {
        "name": {
            "type": "string"
        },
        "members": {
            "type": "array",
            "items": {
                "type": "string"
            }
        }
    },
    "required": ["name", "members"]
}

As you can see, we are defining an object with two fields, name and members. The first one of type string, the second one of type array, with its items of type string. If the request doesn't follow this schema, the Lambda function won’t be executed.

Paste the JSON, insert a name, and set the Content-type to application/json, like this:

Once the model has been created, go to "Resources", click on "Actions" and "Create Method". Select any HTTP Verb you may like, like POST or GET. Once created, select the Lambda Function we just created and create the method. Now Click on Method Request, select Validate body on Request Validator and select the model we just created on Request Body, as on the screenshot:

Now, click again on "Actions" and deploy the API. Wait a few seconds, and now if you try to do a bad request, you will get an error.

Add API Keys to Amazon API Gateway

Our API is working and open to the world. We may want to limit this by accepting only requests which include an API Key.

But first, we need to create usage plans. For this, just go to "Usage Plans", hit on create, select a name, and the options about throttling and quotas that you would like to have.

Now we can go to "API Keys", create an API Key and assign it to the usage plan. Of course, we can create many different API Keys and usage plans, and of course, we can also do this programmatically using the AWS CLI or the SDK for Go.

Once API Key is created and assigned to an usage plan, we only need to pass it on our request as a header with the name x-api-key.

And that’s all ;)

Using the Amazon S3 SDK v2 for Go

Antonio Sánchez — Sun, 26 Sep 2021 17:32:28 +0000

Two years ago, I published the article "Upload files to Amazon S3 with Golang" explaining very briefly how to do some basic operations with Go and Amazon S3. Surprisingly, the article was very successful and two years later it still gets over one thousand visits monthly.

Since Amazon upgraded the SDK for Go to version 2 some time ago, I have decided to create a new article adapting the examples to the new SDK. You can find here all information about the AWS SDK v2 for Go.

As well as on the first article, I am going to show here how to connect to S3 using Go, upload a file from a form to an AWS S3 bucket, download it, and list all items saved on this bucket.

I am going to suppose that you have already:

created an AWS account
created an Amazon Simple Storage (S3) Bucket
generated the credentials to access it (Access key ID and Secret access key)

I am not going to explain those things here since there are plenty of good tutorials on the Internet about it.

Set up your credentials

If you haven't done it yet, remember to save your credentials using the configure command of the AWS CLI or just creating a file like described below on ~/.aws/credentials on Linux, macOS, or Unix. If using windows, create it on C:\Users\USERNAME.aws\credential.

Contents of the file:

[default] 
aws_access_key_id = your_access_key_id 
aws_secret_access_key = your_secret_access_key

Install the SDK

Create your Go project by executing:

go mod init example

And retrieve the standard set of SDK modules by doing:

go get github.com/aws/aws-sdk-go-v2
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/s3

The Code

You can skip all explanations below and check the code directly on https://github.com/antsanchez/goS3example/.

I have tried to keep the code as minimal as possible.

Connect to AWS S3

Connecting Go with Amazon S3 is easy.

package main

import (
    "context"
    "log"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
)

const (
    AWS_S3_REGION = "" // Region
    AWS_S3_BUCKET = "" // Bucket
)

// We will be using this client everywhere in our code
var awsS3Client *s3.Client

func main() {
    configS3()
}

// configS3 creates the S3 client
func configS3() {

    cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(AWS_S3_REGION))
    if err != nil {
        log.Fatal(err)
    }

    awsS3Client = s3.NewFromConfig(cfg)
}

If for some reason you want to programmatically introduce the credentials (if for instance you have to easily switch credentials, or you need to use in your code different buckets from different accounts), you can do it like this:

import "github.com/aws/aws-sdk-go-v2/credentials"

// ...

// configS3 creates the S3 client
func configS3() {

    creds := credentials.NewStaticCredentialsProvider( your_access_key, your_secret_key, "")

    cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithCredentialsProvider(creds), config.WithRegion(AWS_S3_BUCKET))
    if err != nil {
        log.Printf("error: %v", err)
        return
    }

    awsS3Client = s3.NewFromConfig(cfg)
}

Upload a file from a form to Amazon S3

Let's see how upload a file form a form to Amazon S3 using Go and the http package.

First, get the file from the Form:

file, header, err := r.FormFile("file")
if err != nil {
    // Do your error handling here
    return
}
defer file.Close()

filename := header.Filename

Then, upload it to S3:

import "github.com/aws/aws-sdk-go-v2/service/s3"
import "github.com/aws/aws-sdk-go-v2/feature/s3/manager"

// ...

uploader := manager.NewUploader(awsS3Client)
result, err := uploader.Upload(context.TODO(), &s3.PutObjectInput{
    Bucket: aws.String(AWS_S3_BUCKET),
    Key:    aws.String(filename),
    Body:   file,
})

Download a file from Amazon S3

Downloading a file from AWS S3 using Go requires only a few lines of code:

import "github.com/aws/aws-sdk-go-v2/service/s3"
import "github.com/aws/aws-sdk-go-v2/feature/s3/manager"

// ...

// Name of the file where you want to save the downloaded file
var filename string

// Key to the file to be downloaded
var key string 

// Create the file
newFile, err := os.Create( filename )
if err != nil {
    log.Println(err)
}
defer newFile.Close()

downloader := manager.NewDownloader(awsS3Client)
numBytes, err := downloader.Download(context.TODO(), newFile, &s3.GetObjectInput{
    Bucket: aws.String(AWS_S3_BUCKET), 
    Key:    aws.String(key),
})

List the items of an AWS S3 Bucket

Listing an entire S3 bucket or the contents of a folder is very easy using Go.

About folders, there aren't really any folders in S3, but we can emulate them by using "/" in the key names of the objects. In case we want to list the contents of a "folder" in S3, what we really need to do is to list all objects which have a certain prefix.

import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

var prefix string       // For instance, list all ojbects under /bar/foo/ ...
var delimeter string    // ... using "/" as delimeter

paginator := s3.NewListObjectsV2Paginator(awsS3Client, &s3.ListObjectsV2Input{
    Bucket:     aws.String(AWS_S3_BUCKET),
    Prefix:     aws.String(prefix),
    Delimiter:  aws.String(delimeter),
})

for paginator.HasMorePages() {
    page, err := paginator.NextPage(context.TODO())
    if err != nil {
        // Error handling goes here
    }
    for _, obj := range page.Contents {
        // Do whatever you need with each object "obj"
        fmt.Println(obj.Key)
    }
}

And that’s all.

Launching Found.dev

Antonio Sánchez — Fri, 23 Apr 2021 07:11:56 +0000

For over a year, I have been working on a side-project in my spare time. It all started as a way to keep improving my knowledge and expertise with Go by coding, but at some point, I decided I could give it a try and make a business of this project.

At the end of March 2021, I decided the project was ready to see the light, so I launched Found.dev.

What is Found.dev?

As described on the FAQ of the site, it is much more than simply a job board for developers. It is a place where developers can have a public developer profile, find jobs and apply to them, while companies can post jobs, have a public profile too, look for developers, and manage applications.

Why another job board?

It was never my intention to do a job board. It just happened.

In the beginning, I was doing something like a database of developers: somewhere, where developers could have a profile and a recruiter could search for them.

But during the process of idea validation, I changed the direction a few times, until I ended up creating yet another job board.

At this moment, I can’t tell if I’ll keep the project in this direction or if it will again pivot as I see how the users interact with it and the feedback I receive.

How is it going?

A few weeks after launch, it is going as expected: not so good.

This is a product with a lot of well-established competitors who have been for a long time on the market and who have a lot of users already. Furthermore, it is difficult to get companies to post without having enough developers, but developers won’t register without enough job posts.

But this was all expected. I continue writing to some hand-picked companies and developers every day to invite them to register, and I don’t know if I am getting better and better and writing or what, but the percentage of users that are registering is continually increasing.

The big problem is the lack of time. Due to my job at Kokoen, I can only use a few hours a day (and not every day) for this project, so it will be a slow process.

What things have I done wrong?

Many things. Even though I am experienced enough with launching products/startups, I have made some huge mistakes that I shouldn’t have done, since I knew that those are typical launch mistakes...

The bigger mistake has been developing the whole product without building an audience first. This is a beginner's mistake, and I am afraid (and ashamed) that I have done it again. I completely neglected the social aspect needed to successfully launch a product: have enough audience or distribution channels to make it visible to enough potential users without having to spend money on ads.

Now I am trying to catch up with lost time by being very active in some communities like Indie Hackers, Reddit, some developer's websites, etc... But to do this well, I need more time than I have. Twitter is working the best: I am not only posting all jobs there but also engaging with the community by answering tweets, sending DMs, etc... And even though the number of followers isn’t growing much, it is driving way more traffic than expected. Maybe it is working so well because I am using some tools to export Twitter data to address exactly the users I want to.

Do you want to join?

Right now, only developers and companies with an invitation code can join in. This is to assure a certain level of quality. If you think you qualify for this, please contact me!

Which are the running costs of an App?

Antonio Sánchez — Wed, 11 Nov 2020 14:50:30 +0000

An app's running costs can span from zero to infinite, depending on many factors like the functions the app offers, the number of active users it has, the required server capacity, or the services from third party suppliers it relies on. I will examine here the most commons of those factors and their costs.

For every requirement or function an app has, there are multiple options on how that need can be covered: some of those solutions are open-source and free but require more developing time and costs or to manage your own server; some of them are subscriptions or pay-as-you-go fully managed services offered by third-party providers.

There are mainly five types of running costs that almost every app has:

App Stores fees.
File Storage, for storing/uploading/downloading all needed files.
Database, for keeping all data that the app needs to run.
Server, for having one or many APIs to connect to.
Third-Party APIs, like Google Maps API, Payments APIs, Chats, etc..

But before I continue, there is some good news you will be happy to hear: nowadays, there are a lot of serverless and cloud providers like Firebase, Netlify, Heroku, or AWS that offer all services your app may need for very little money. If your app has only a few thousand users, the cost of using those services, maybe even zero.

Does my app need any Server or API at all?

If your app doesn't offer any user account that needs to be synced betIen devices, nor any content that must be downloaded or uploaded from/to one specific central location, you may need no infrastructure or APIs at all. In that case, everything can be done directly within the app or even with no internet connection.

Foreseeable costs vs. Pay on demand

When deciding which provider or solution to use, the main question is if you prefer to have foreseeable fixed costs or choose to pay based on demand (depending on the app's real usage).

Foreseeable costs can be achieved by traditional means: having a contract for a fixed amount of time with any hosting provider and managing yourself everything. Sure, you will have more security about your costs, since they are already set. Still, suppose your app starts growing beyond your expectations. In that case, it is difficult and costly to scale since you will need to renegotiate the contract with your provider or manually add more servers to your infrastructure.

Foreseeable costs do not always mean feIr costs since you may be paying for capacity that you are not using: maybe you book a 2 Terabyte server, but your users are only using a few Gigabytes from that storage! Furthermore, foreseeable costs typically imply that you are in charge of managing your infrastructure yourself, which means more costs for this management.

By choosing to pay on demand, you will have a broad spectrum of serverless or PaaS options available that reduce or even eliminate the complexity when scaling is needed, making the process even wholly automatic. You will pay based only on what you consume so that there won't be any need to plan how many resources you need and not pay for resources you are not using.

Also, services offered on-demand typically imply that you have little or no infrastructure to manage at all since your provider will take care of everything. You only have to use the service, which means feIr or no costs for those managing tasks.

I believe paying on demand is the option that makes more sense in most cases, if not all cases, and for this reason, I will base our article only on this option.

App Stores Fees

How much does it cost to have an app in the App Stores?
The running costs of having an app in the Apple App Store and Google Play Store are almost zero. Neither Google nor Apple charges any recurrent amount of money for making your app available in their stores. HoIver, they charge a developer fee to create an account that you can use to upload as many Apps as you want.

Apart from this developer fee, you may also take a commission from the money users pay you for abonnements or in-app-purchases if you offer this in your app. Those commissions are only for digital purchases (goods or services consumed within the app, like premium features or any other kind or content of function offered in the app only after paying for it). Non-digital purchases (all those goods or services consumed outside the app, like any physical products being sent to the user after buying them) are exempt from this commission.

The price guidelines of both Apple and Google are very similar.

What are the costs of having an App in the Apple App Store?

The needed developer account has a yearly fee of 99 USD. In case you want to distribute your app only within your company or organization, you would need to apply for the Developer Enterprise Program, which cost 299 USD yearly. With one account, you can upload as many apps as you want.

For digital subscriptions or purchases, Apple takes a 30% commission. This commission will be loIred to 15% after the first subscription year, per subscriber in case of auto-renewable subscriptions.

What are the costs of having an App in the Google Play Store?

The needed developer account at Google is a one-time payment of 25 USD. With one account, you can upload as many apps as you want.
Exactly as for Apple, subscriptions and digital purchases have a 30% commission. After the first subscription year, the commission decreases to 15%.

File Storage costs

Your app users may most probably need to upload or download some files, like images, videos, or documents. Those must be stored somewhere on the Internet to be uploaded and downloaded at any given time and synced with different devices.

The most used service and almost industry-standard is Amazon S3. This service offers a highly, scalability, availability, security, and performance, starting from just a few cents. Here you pay for what you use.

Let's say your app is a kind of social network that has 20.000 users. Each user has an average of 10 pictures of 4MB each. Your daily active user is 4.000. I calculate 800 GB of storage needed, 2.400 GB of data transfer, and 6.000.000 requests based on those numbers. This scenario would cause an estimated cost of about 38 USD monthly. You can calculate yourself the price here: https://calculator.aws/#/createCalculator

Database costs

Your app's data lives on a database: your user's accounts, all the information that they save, or all information that they see in the app.
Database costs depend on the database capacity (how much info needs to be saved), the poIr of the database (CPU performance and read replicas), and the availability (backups, clones, and so forth..). The more users your app has, or the more data needs to be fit in the database, the more it will cost.

For tiny apps with just about 2.000 users, the free tiers that most providers offer may be more than enough.

For small and medium apps with less than 20.000 users, I estimate a cost of betIen 50 USD and 100 USD a month based on our experience.
But again, as I said above, this may vary a lot from app to app. Some Shops may have only a thousand users (or visitors but have a database with millions of products on it. In this case, a potent server is needed to query those products and quickly deliver the results, increasing the costs. Or this shop may also need a very high availability to avoid losing any purchase, which may require some extra measures like having redundant databases, which can also multiply the costs.

Server Costs

Not all functions that an app offers are run in the app. Some of these functions are done server-side like login/registering users or sending the queries to the database for searching and filtering.

The number of users is not significant here, but the usage: how many concurrent active users your app has and how much CPU poIr it needs.
There is also a multitude of options here. To avoid costs related to the server's maintenance and avoid scalability or security issues, it is recommendable to choose a cloud provider, no matter if serverless or PaaS. Due to its simplicity, I usually recommend Heroku or Firebase. Depending on your app's needs, you may also choose the serverless services from any of the big players like AWS, Google Cloud, Microsoft Azure, etc.

Suppose you chose Heroku, the cost of running your API start at 7 USD. And this may be more than enough for small apps with just a few thousand users.

If your active user base starts to grow or the functions that your API needs to run require more poIr, you may upgrade to a monthly cost of 25 USD to 50 USD, which should be enough for apps that less than 10.000 daily active users. That should be enough for the social media app I describe in our first example.

For more than 10.000 daily active users, I would calculate a cost of above 100 USD monthly if you want your app to run quickly and smoothly enough.

These costs described for Heroku are very similar to all other providers.
Again, this may vary a lot from app to app, depending on its usage.

Third-party APIs

Coding everything from scratch makes no sense: it is costly, challenging to keep up to date, and requires much effort for the maintaining. It is better to take the advantages that certain providers already offer for quickly implementing some functions in your app.

Payments

If your app accepts payments, you may need to use the payment solutions I already discussed on the first point of this article, so there is no need to repeat it.

But in some other cases, you want or need to implement your payment solution. For this, you will need to use providers like PayPal, Stripe, or Adyen. They offer all your app needs to receive and send money from/to your users.

Those APIs are mostly free to use, and you only have to pay them a percentual commission for every transaction. Those commissions vary depending on the plan you subscribed to with the provider, the volume of transactions, and the features you are using, but mostly they span betIen 1,4% and 3% per transaction.

Push Notifications

A must-have in most apps are push notifications. As for all other functions, there are different ways of how this can be implemented.
Push notifications are sent from a server and received by the app. That means that at least a specific software and a server are needed to send the apps' notifications.

A few open source solutions can be used for free to implement push notifications, like socket.io. HoIver, you would still need some server to host this software and dedicate some efforts to maintain that server. I recommend using a provider like OneSignal or Firebase Cloud Messaging to avoid unnecessary costs, reduce complexity, and increase stability, scalability, and security.

The prices here vary depending on the number of notifications needed to be sent or the number of users receiving push messages. For most of the apps, those services can be used for free, and you only have to pay if you reach a large number of users or want particular features like Analytics or Intelligent delivery.

Google Maps and Google Places

Most apps need to include at least one of those features:
A Google map.
Geolocation to see where the user is located.
Some form where the user can insert a street or any other kind of location.
For all those services, the API of Google Map or Google Places is required. The prices vary depending on the number of requests your apps do to Google.

Using a Google Map on your app, you will pay 2 USD for every 1.000 loaded maps (this is 1.000 users, loading the map once).

If you need some search or filter by location on your app, you will need to use the Geocoding functionality of Google Places for converting addresses to and from geographic coordinates. For every 1.000 requests, you will have 5 USD costs.

If you want to give the user the ability to insert any address on a form, your app will need the Autocomplete function, which costs 2.83 USD for every 1.000 requests.

The good news is that Google offers a monthly 200 USD in free usage, so most of the small apps with only a few thousand active users won't have to pay a single cent since with this 200 USD, you will have enough for having 100.000 API request. That is the equivalent of more than 3.300 active users loading a map every day.

Chat

Similar to push notifications, there are enough open-source solutions hosted in almost any server to make your chat run. The problems with those solutions are mainly three:
You will need to manage a server that can cope with all users your app has.
Almost everything must be developed from scratch on the app.
If you want some advanced features like video chat, you will have to implement it extra.
For saving unnecessary costs of self-managing a server as Ill as reduce the time and cost of development, the usage of a provider like CometChat is recommendable.

Again, the prices here depend on usage. Using CommetChat, the price starts at 49 USD per month for 1.000 monthly active uses and 50 concurrent users. If you have more users or want to add some features like video calls or chatbots, the price will also go up. You can check yourself all possible combinations here: https://www.cometchat.com/pro-pricing.

Yes, this price may sound a lot if you have many thousand users. But it is still very cheap compared to all the money you save by not having to manage your chat server and not having to develop most of the functions like Video Chat or Chat Bots that are already available with a single click by using such a provider.

Summary

I know, even for an experienced developer, the number of options, prices, advantages, and disadvantages can be overwhelming. So don't feel bad if you still don't know how much running cost your app may have or if you didn't even thoroughly read the article. I will try to give you here a basic orientation based on the number of users and functions.

Please, note that this is only an example for orientation purposes. Your app's real cost may vary depending on the functions and the grad of security, availability, and speed your app or infrastructure offers.

Let's suppose an app that requires file storage, database, server, google APIs, and push notifications, as described above. I won't consider any discounts like the AWS Free Tier or the Free Usage offered by Google. Chat will be calculated separately. Chat is not considered in this example.

The prices indicated are the average of our estimations: neither the loIr nor, the higher estimated price.

Estimation for a few hundred active users: from $5 to $15.
Estimation for about ~2.000 monthly active users: from $15 to $50.
Estimation for about ~5.000 monthly active users: from $25 to $70.
Estimation for about ~10.000 monthly active users: from $50 to $100.
Estimation for about ~20.000 monthly active users: from $70 to $150.
Estimation for about ~50.000 monthly active users: from $100 to $250.

You can also read this article in German here: Wie hoch sind die laufenden Kosten einer App?

How we develop apps reducing time and costs

Antonio Sánchez — Wed, 29 Jul 2020 15:50:21 +0000

During the last years, at Kokoen, we have specialized in creating mobile applications while reducing to the minimum time and costs of the development. Here is an overview of how we have achieved it.

Understanding the client needs

After receiving a client request, the first thing we want to define is what the client really needs to build. This may be very different from what he wants to create, and it is for sure, very, very different from what he says he wants to create.

The best thing here is not to waste time with non-ending conversations and documents with a lot of technical specifications. Writing the requirements is a good idea, but mostly only to define the "big picture" of what the app should be able to do and some specific desires that should figure on the contract. However, writing all minor technical details in a paper is inefficient since it is impossible to estimate all needs, questions, and problems that developers may have just imagining how the app should be.

Instead, we try to build a click dummy to help the customer and our self visualize what we are trying to do and specify all technical details and requirements working on this click-dummy in an on-going way.

Building a click dummy will help define the requirements better and discover problems or questions that, without a click-dummy, would have remained hidden.

Working Agile – Defining the Increments

Requirements may change and will undoubtedly change. So, why to focus now on elements that may never be coded or, even worse, that may be recoded soon? That's why we prefer to work agile!

Agile's concept turns the traditional way of working of a company entirely upside down - in the most real sense of the word. Agile companies distribute responsibility away from management to the developer teams. Those teams take responsibility for their own actions. The management gets a completely different role. Control and guidance become support and encouragement for employees (keyword: Servant Leadership). The pyramid is reversed, what is now needed is a broad platform supported from below on which employees can work successfully. Clear goals and guidelines replace small-scale planning, enabling a rapid response to changes and unexpected events.

The control function is taken over by the team itself. Not only does the team monitor the work progress, but it also continually tries to improve, remove obstacles, and distribute tasks sensibly. This is successful when all team members know the goals or visions they are working towards. Ideally, they have even participated in the formulation of these goals or visions.

Three steps quickly lead to more agility:

1. Organize subprojects:

The overall project is divided into sub-projects, each of which generates added value for the customer. It is important that the sub-projects do not overlap so that they can be pursued independently. Each sub-project must be broken down into concrete tasks before it can be processed.

2. Short-term planning:

Only the next and the subsequent subproject is planned since these are the only subprojects for which the necessary details are usually available. For future sub-projects, the available information is often too imprecise; the risk of changes and replanning is high.

3. Take the customer's view:

The partial and overall project result is formulated from the customer's point of view. This way, all team members do not lose sight of the goal and can react independently in the customer's mind if problems arise, whereby customers can be external or internal.

The sum of all completed tasks at the end of a chosen time period (the so-called sprint) is called the Done Increment. The increment is the integration of the currently completed tasks with all tasks completed in previous sprints . We prefer to work with weekly increments. In a new project, there are usually still many uncertainties and unsolved problems/questions. These represent risks for the development because the effort of individual requirements can be estimated only with difficulty. Therefore, it is obvious to work in the smallest possible units, especially if the project is still in an early phase. Do you wonder what the advantages of this way of working are? Here they come:

Regular reflection of the development process
Use software productively as early as possible and then expand incrementally
Present regularly running software to stakeholders

Reducing risks with MVPs

These advantages are also the reason why we work with the so-called "Minimum Viable Product" (MVP), a product with the minimum requirements and characteristics that still makes the product worth using. When developing an MVP, the basic idea is to create a product as quickly as possible, with only the most necessary features. This is then published immediately, and feedback is first sought from (potential) customers. This feedback is used in the following to expand and improve the MVP.

Any further functions should be left out of the MVP. Only those functions that are necessary to enable the actual purpose of the product will be included. This saves a lot of time, work, and money.

The main reason for developing an MVP is to minimize risk. If you choose the path of developing and releasing a complete product, many problems can arise.

For example, developing such a full-fledged product takes a lot of time and money. Far more than it would be with the development of an MVP.

Another risk is the development of ignoring the real market and customer needs. If months of development are invested in a product, but nobody wants to have it after release, everyone has just wasted its time and money on building something no one needs.

The development of an MVP, on the other hand, reduces the risk for companies by developing only a prototype with the most necessary functions and initially saves the company a lot of time and money. Besides, early market entry quickly evaluates whether the idea and the product have any chance at all on the market.

Using the best-fitting technologies

Before we start developing, we spent a lot of time discussing which technologies we should use and how the application should be developed - entirely in the spirit of "Weeks of coding can save you hours of planning." The fundamental question in app development is, of course, the requirements and the desired platforms. Combined with the available budget, this simple calculation results in the final development strategy.

There are nowadays different ways of coding an app: Native, Hybrid, Compiled, and PWA. Each of them has its advantages and disadvantages, and choosing the correct one can make you save tons of money and time. You can read more about this here: Overview of App Development Options

Of course, it is not possible to make a generally valid assessment for individual projects. Simple requirements can indeed be implemented web-based and distributed in the app stores via a native framework. Often, however, the current technological limitations push the project to its limits. In this case, a hybrid solution is usually an excellent alternative from a cost/benefit point of view. However, if the requirements are too complicated or elaborate or if you enter the terrain of game development, you can hardly avoid a native development.

Do you have any questions or need consultancy about transforming your idea into an app? Do not hesitate to contact me.

CORS and OPTIONS problems with Go and Angular

Antonio Sánchez — Sat, 01 Feb 2020 18:15:17 +0000

Lately, I have been working on some web app projects which were combining Go for the Back End and Angular for the Front End. Although both are very widely used, it looks like CORS is still a problem for many people when using this combination of Go and Angular.

After searching on Google for some questions or problems I had, I saw many no answered questions or - what it is worse - bad responded to questions about this.

I won't explain in detail here what CORS is or how it works since there is already a lot of good literature about this on the internet like this https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS. All you have to know in case you are not familiar with CORS is:

When running Angular and the Go API each in a different domain, protocol, or port, some headers must be set on the API to allow the Cross-Origin Resource Sharing (CORS) - this is, to allow your browser access the API.
Angular - or better said, your browser - will not directly send a POST or GET request to this API, but it will first send an OPTIONS request. This OPTIONS request is just a "preflight" request soliciting which HTTP methods are supported by the API and check if the proper headers for CORS are set. This OPTIONS response is supposed to return an HTTP 200 Status Code as well as the headers required for CORS.

Point one seems to be clear for almost anyone if you take a search about it on Google. But most people seem to ignore point two.

How to handle this CORS and OPTIONS problems when working with Angular and Go? Well, you don't have to do anything in Angular, only in Go. Here is a middleware example for using the Framework Gin:

Custom CORS Middleware with Gin:

// CORS Middleware
func CORS(c *gin.Context) {

    // First, we add the headers with need to enable CORS
    // Make sure to adjust these headers to your needs
    c.Header("Access-Control-Allow-Origin", "*")
    c.Header("Access-Control-Allow-Methods", "*")
    c.Header("Access-Control-Allow-Headers", "*")
    c.Header("Content-Type", "application/json")

    // Second, we handle the OPTIONS problem
    if c.Request.Method != "OPTIONS" {

        c.Next()

    } else {

        // Everytime we receive an OPTIONS request, 
        // we just return an HTTP 200 Status Code
        // Like this, Angular can now do the real 
        // request using any other method than OPTIONS
        c.AbortWithStatus(http.StatusOK)
    }
}

func main() {

    r := gin.Default()

    // We use our custom CORS Middleware
    r.Use(CORS) 

    // ... here the routes 
    r.POST("/login", loginController)

    r.Run()
}

Custom CORS Middleware with Gorilla Mux:

// CORS Middleware
func CORS(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

        // Set headers
        w.Header().Set("Access-Control-Allow-Headers:", "*")
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "*")

        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }

        fmt.Println("ok")

        // Next
        next.ServeHTTP(w, r)
        return
    })
}

func main() {

    r := mux.NewRouter()

    // We use our custom CORS Middleware
    r.Use(CORS)

    // ... here the routes 
    r.HandleFunc("/login", loginController)

    http.Handle("/", r)
    http.ListenAndServe(":8080", r)
}

Note that you could use this "standard" Middelware package for Gorilla https://www.gorillatoolkit.org/pkg/handlers and this for Gin https://github.com/gin-contrib/cors.

Upload files to Amazon S3 with Golang

Antonio Sánchez — Fri, 01 Nov 2019 17:27:27 +0000

Connecting your Go application with Amazon S3 is pretty easy and requires only a few lines of code. But if you have no experience with Amazon Web Services, it can get pretty tricky at the beginning to figure out even the most straightforward task.

We are going to see here how to connect to S3 with Golang, upload a file from a form to an S3 bucket, download it, and list all items saved on this bucket.

I am going to suppose that you have already:

created an AWS account
created an Amazon Simple Storage (S3) Bucket
generated the credentials to access it (Access key ID and Secret access key)

I am not going to explain those things here since there are already plenty of good tutorials on the Internet about it.

Set up your credentials

After having created the S3 Bucket, the very first thing that we are going to do is to save the credentials.

There are a few ways of doing this as described here https://docs.aws.amazon.com/es_es/sdk-for-go/v1/developer-guide/configuring-sdk.html

We are going to use the easiest one using a shared credential file. For this, create a file like described below on ~/.aws/credentials on Linux, macOS or Unix. If using windows, create it on C:\Users\USERNAME\.aws\credential.

[default] 
aws_access_key_id = your_access_key_id 
aws_secret_access_key = your_secret_access_key

Install the SDK

After this, we need to install de AWS SDK for Go:

go get -u github.com/aws/aws-sdk-go/...

and import the AWS packages into your Go application:

import ( 
    "github.com/aws/aws-sdk-go/aws" 
    "github.com/aws/aws-sdk-go/aws/session" 
    "github.com/aws/aws-sdk-go/service/s3"
)

The Code

You can skip all explanations below and check the code directly on https://github.com/antsanchez/goS3example.

I have tried to keep the code as minimal as possible.

Connect to AWS S3

I like to use this code on my main.go file or whatever other file where I can share the session (sess variable) to reuse it.

const (
    AWS_S3_REGION = ""
    AWS_S3_BUCKET = ""
)

var sess = connectAWS()

func connectAWS() *session.Session {
    sess, err := session.NewSession(
            &aws.Config{
                Region: aws.String(AWS_S3_REGION)
            }
        )
    if err != nil {
        panic(err)
    }
    return sess
}

Upload a file from a form to Amazon S3

First, get the file from the form:

file, header, err := r.FormFile("file")
if err != nil {
    // Do your error handling here
    return
}
defer file.Close()

filename := header.Filename

Then, upload it to S3:

uploader := s3manager.NewUploader(sess)

_, err = uploader.Upload(&s3manager.UploadInput{
    Bucket: aws.String(AWS_S3_BUCKET), // Bucket to be used
    Key:    aws.String(filename),      // Name of the file to be saved
    Body:   file,                      // File
})
if err != nil {
    // Do your error handling here
    return
}

Download a file from Amazon S3

First, create a temporary file where to store the downloaded file:

f, err := os.Create(filename)
if err != nil {
    // Do your error handling here
    return
}

Now, download the file and do whatever you want with it (f)

downloader := s3manager.NewDownloader(sess)
_, err = downloader.Download(f, &s3.GetObjectInput{
    Bucket: aws.String(AWS_S3_BUCKET),
    Key:    aws.String(filename),
})
if err != nil {
    // Do your error handling here
    return
}

List the items of an AWS S3 Bucket

svc := s3.New(sess)
input := &s3.ListObjectsInput{
    Bucket: aws.String(AWS_S3_BUCKET),
}

result, err := svc.ListObjects(input)
if err != nil {
    if aerr, ok := err.(awserr.Error); ok {
        switch aerr.Code() {
        case s3.ErrCodeNoSuchBucket:
            fmt.Println(s3.ErrCodeNoSuchBucket, aerr.Error())
        default:
            fmt.Println(aerr.Error())
        }
    } else {
        // Print the error, cast err to awserr.Error to get the Code and
        // Message from an error.
        fmt.Println(err.Error())
    }
    // Do your error handling here
    return
}

You could now list the items showing the name like this:

w.Header().Set("Content-Type", "text/html")

for _, item := range result.Contents {
    fmt.Fprintf(w, "<li>File %s</li>", *item.Key)
}

More information

There are plenty of tutorials on internet, but not all of them are updated or following the best practices.
I would recommend you to check those links:

And that's all.

The power of defer in Go: on entry

Antonio Sánchez — Tue, 23 Apr 2019 08:36:00 +0000

Here is a small tip I wish I would have learned earlier when I started coding with Golang: using defer in both the start and exit of any function.

Although this is a very basic concept that can be extremely helpful when debugging code, it is difficult to find any information about it in most of the Golang tutorials you can find on the Internet.

Defer is one of the first things you learn when starting to code with Go. It is pretty straightforward: inside any function, you prefix some other function with defer to make sure this function is executed right before the parent function exits, no matter what. Even if the parent function panics, this defered function will run.

In case you are not familiarized with defer, take a look here before continuing reading this article: Go by Example: Defer.

However, there is something that you may haven't read on any of the examples or tutorials you have found: you can also use defer to pair code at the start and the end of any function.

To use this, create a function and make it return another function itself, which will be the real deferred function. Defer this parent function and add extra parenthesis to it when deferring it, like this:

func main() {
    defer greet()() 
    fmt.Println("Some code here...")
}

func greet() func() {
    fmt.Println("Hello!")
    return func() { fmt.Println("Bye!") } // this will be deferred
}

Which outputs this:

Hello!
Some code here...
Bye!

The function returned by the deferred function will be the real deferred function. The other code inside the deferred function will be executed right at the start of the function (or wherever you place it).

Why is this awesome? Well, as you can see in the next example, you can use variables on the deferred function that can be accessed both on the first execution and the deferred execution:

func main() {
    example()
    otherExample()
}

func example(){
    defer measure("example")()
    fmt.Println("Some code here")
}

func otherExample(){
    defer measure("otherExample")()
    fmt.Println("Some other code here")
}

func measure(name string) func() {
    start := time.Now()
    fmt.Printf("Starting function %s\n", name)
    return func(){ fmt.Printf("Exiting function %s after %s\n", name, time.Since(start)) }
}

Which outputs this:

Starting example
Some code here
Exiting example after 0s
Starting otherExample
Some other code here
Exiting otherExample after 0s

As you can imagine, deferring code to use it on the entry and the exit of any function can be extremely useful, especially for debugging your code.

You can see another example here: https://github.com/adonovan/gopl.io/blob/master/ch5/trace/main.go