Start-up journey

Intro

At the turn of September and October 2024 I left Point72 and started working at the ConnectyAI startup as a founding engineer. After two years, my startup journey has come to an end. In this post I'd like to sum up my feelings and thoughts about my work during that period.

Why a startup?

After years of working in large organizations (PwC, Allegro Pay, Point72), often experiencing:

  • no direct impact on the end product and its users
  • a relatively slow pace of shipping changes
  • a relatively large number of processes, procedures, and general bureaucracy
I thought more than once about working at a startup or on my own project. Having gained quite a lot of experience, I knew that technically and operationally I could handle a much broader scope. The vision of designing and developing a product which would actually solve real problems, and in effect make users' lives easier, seemed very attractive.

On the other hand, I was of course aware of the usually faster pace of work, greater responsibility, and less financial security. Nevertheless, I decided that if such an opportunity came up, I'd give it a try. I had plenty of ideas for my own startup, but almost all of them were technical products for programmers or data engineers. I knew that even with optimistic estimates, it's very hard to monetize such products (and that was still before the AI boom that was about to come).

ConnectyAI

In August 2024 I had initial talks with the CEO of ConnectyAI, a newly founded startup. From the very beginning I really liked the CEO's approach and vision for the product. It was very close to what I would like to work on myself. At that stage ConnectyAI was building out its engineering team and looking for founding engineers. After a few conversations I tentatively agreed to join once ConnectyAI closed its first funding round. It happened much sooner than we expected, and in September 2024 I joined the team full-time.

The goal of ConnectyAI was to build a platform which would give non-technical people (product managers, marketing, etc.) direct insight into data, analyses, and results, without the need to know the technology or to delegate tasks/questions to data analysts or engineers. For technical people, on the other hand, the platform would make a large part of data-related work easier. In short, it was meant to be a bit like ChatGPT for data. In our case the main user interface was also a chat embedded in a web application. I really liked that vision.

Beginnings

In the early phase my main areas of responsibility were infrastructure (AWS) and backend in general (Go). We were starting from scratch, so initially there was a lot of work around designing and deploying the architecture, setting up environments, CI/CD pipelines, the local environment, and implementing the backend skeleton which would support the operations of the web application. On top of that, there was user authentication. A series of tasks that were necessary before we could even start implementing the key features. Looking back, by startup standards, we spent a bit too much time on this stage, but we'll come back to this topic later.

Chat

One of the first features I had to build on the backend side (apart from the ones mentioned above) was the chat. Go was a perfect fit for this task! The combination of goroutines, channels, and websockets (gorilla/websocket) allowed me to build a stable and scalable chat in a relatively short time. It was one of those things I had never implemented in a production environment before (only in simple experiments while learning). It was a very interesting and satisfying experience.

RAGs and agents

Our initial approach to applying LLMs to our problem was to prepare the best possible context for a set of specialized agents. At that time it was a natural and commonly used approach. This was still before Claude Code came out and before the agentic approach matured significantly.

Context selection was a combination of searching through properly prepared vectors (pgvector in PostgreSQL) and our internal, enriched context of the data model. Nowadays we could say that back then we were working on a specialized harness for LLMs in the context of databases.

Data sources

Another big and important area covered by the backend was designing and implementing support for various data sources. In the early phase these were mainly SQL databases (PostgreSQL, Snowflake, Databricks, etc.). The challenge of designing the internal API was a classic problem of its kind. We want an API which can be implemented by as many data sources as possible, but on the other hand it should be explicit and useful enough for internal services. All in all, looking back, I think it turned out pretty well.

The implementation itself was fairly simple, especially with the help of LLMs (once we had 1–2 solid implementations, LLMs were pretty good at adding new ones). On the execution side, more work went into covering connection configuration and supporting the possible authentication paths. That had to be documented and implemented on the frontend side as well. Still nothing hard, but adding support for a new data source required some work and quite a lot of testing.

<X> for data

The first few months at ConnectyAI showed us very tangibly that the problem space of solutions for "data" is incomparably larger than in the case of solutions for "code". Of course I had been aware of this for a long time, but only then, while working intensively on this kind of product, did I really feel it.

One example from the aforementioned group is "git for data". The idea is beautiful and simple. We want to be able to version data, just like we do with source code. Easier said than done. Of course many solutions of this kind have been created, but none of them gained even a fraction of the popularity Git has. That's not the fault of the solutions themselves, the problem is simply much harder. Different data formats, the "places" where data is stored, the sheer scale of data, etc. All of this makes it far more difficult than in the case of source code.

At ConnectyAI there were many challenges resulting from the larger problem space of data. Let me mention one of them as an example. A seemingly simple task: we want to have a sample of rows for a given column of a given object in a database. For example:

{
  "schema.table1.col1": [42, -5, 0, NULL, 1]
}
We assume that the sample size is small and fixed upfront (e.g. 5 or 10 rows). For simple numeric types there's no problem. However, if the column is of type TEXT or JSONB, then for example in PostgreSQL a single value can weigh up to 1 GB. It's probably not a common case, but both the backend (storage and transfer) and the frontend (general UX and rendering) have to be prepared for it (or skip such values and handle them in a different way). Another challenge is how to efficiently sample a large table. That depends on the particular database engine. Most of them support sampling a given number of rows, but not all of them. Yet another problem is the fact that a given object schema.table1, despite its name, might not even be a table, but a view or some other object. In the case of a view, it might be a complex query which operates on potentially large tables or on other views which use large tables. Such a query can be very expensive, both in terms of money and time. It would be rather irresponsible if ConnectyAI (a 3rd party tool) ran queries costing >$100 just to extract a few values for its internal metadata. Some database engines support estimating the cost of a given query, or at least the number of bytes to be read (for example BigQuery and Snowflake). When such capabilities aren't available, we have to design a heuristic analysis based on other available metadata, to minimize the chance of such situations.

Today (2026, two years later) we can see similar solutions from big vendors: Google (BigQuery), Databricks, and Snowflake. Each of them offers an "assistant" for working with data. Compared to the scope we implemented at ConnectyAI, those solutions are very limited. Which only reinforces the point about how complex the problems in this space are.

Work dynamics

GitHub Contributions

GitHub activity

GitHub Contributions

Even before I joined ConnectyAI, I knew that the intensity of work at startups is generally high. Potentially higher than in all the places I had worked so far, including consulting (PwC). It wasn't only my personal matter. The intensity and the length of work could potentially affect my family, especially my wife. Fortunately, my wife is very supportive and was okay with this potential new situation. So my full commitment to the startup for at least two years was a conscious investment.

It was just as I expected. There was a lot of work and the pace was high. It didn't bother me, because we were developing our vision and bringing it to life. The work dynamics also reflected the dynamics of our collaboration with design partners and early customers. The previously missing element of impact on the product and its users was now fully present and tangible.

Despite the high intensity of work and the team being spread across several time zones, we managed to keep some individual flexibility. In general, it came out quite naturally. The pace was driven by our internal vision and plan, and adjusted locally depending on customers' needs.

Regarding the pace of building the product, at every moment it seemed to us that we were working as fast as we possibly could. Which at time t + Δ already turned out to be ridiculously slow, in hindsight. Now, having the whole picture, it's easy to assess and sum it up. You could say that the first 2–3 months were "slow" in terms of the impact on the final product. At that time it seemed perfectly understandable, because we were building the foundations (infrastructure, processes, fundamental features, communication between services, etc.). Moreover, we tried to build those things properly. It was very natural for us. Of course we were aware all along that we were at a startup and iterations should be fast. We thought we understood that back then, but we really felt it much later. From today's perspective I can say that in those first months we still had habits formed while working for large organizations. Every day those habits were more and more confronted with the startup reality. I should also add that those first few months were before the release of Claude Code, Cursor, and more advanced language models. Of course we used a lot of AI assistance, but it was nowhere near the level of late 2025. I remember precisely that I produced at least 100,000 lines of (Go) code in the backend in less than 6 months, back then still without agentic assistance.

I won't give exact productivity statistics here, just my subjective estimate. In the first few months, shipping a medium-sized feature took the whole team between 2 and 5 days. At that time it seemed very fast, especially compared to traditional organizations. However, at the peak of productivity and startupmaxxing, we got to as many as 1–2 big features per day, including deployment to production. That included implementation, testing, deployment, a demo for customers, a discussion with customers, and planning improvements for the next iteration. All of that often within 24 hours (to this day I admire our CTO, who was effectively working two full-time jobs, in the EU time zone with the engineers and in the US time zone with the CEO and customers, to make it happen). The next day, another iteration. I don't have a lot of startup experience, but that's exactly the level of intensity and approach to the product which I'd call the startup approach.

Pivot

After about 15–16 months we had a ready product (by some definition). By that time it had gone through many iterations based on feedback from our design partners and early customers. In the meantime it turned out that selling a general platform for working with data is much harder than we had expected. The two most important reasons were trust and decision-making power. Trust in external vendors who would have access to internal data varies, but it's usually limited (especially in the EU). The second and harder obstacle was decision-making power. Usually the people who tested our solution or were interested in it (CDO, product managers, analytics teams, etc.) didn't have a strong enough position to make a decision about purchasing and deployment. As a result, it had a very negative impact on our sales. Another downside, from the sales perspective, was the generality of our solution. The fact that our solution worked with many database engines and many "types" of data was unintuitive for customers. It's much easier to sell a product which solves a specific problem than one which solves a general problem.

The result was a pivot[1] towards a more vertical solution, solving a specific problem. At that time we didn't even know it was a pivot. From our point of view it was an extension of our functionality with a specific use case. In hindsight it was clearly a pivot. Our new goal was to apply the intelligence we had built around data to problems related to advertising and marketing, with a focus on Meta Ads (formerly Facebook Ads). As I mentioned, we didn't treat it as a pivot, because we leveraged the generality of our platform, and the new features towards marketing and decision-making were a natural extension rather than a rebuild or starting from scratch.

Ideologically I wasn't a fan of working on ads and marketing optimization, but from the startup's perspective it was a good decision. Our CEO had experience in this area and exposure to customers and their problems. Of course we were all aiming for success, so a slight ideological friction wasn't a big obstacle. On the bright side, the new problem uncovered a lot of interesting technical challenges.

Meta Ads

Apart from the interesting challenges, there was also a lot of hard and tedious work. In particular, I mean working with the Meta Ads API. The scars from that experience will stay with me for a long time... This subchapter alone could be a separate post, but here I won't go into details. The first step was understanding the concepts existing in Meta Ads, such as account, campaign, ad set, ad, creatives, assets, etc., and how they relate to each other. That was relatively well documented, but rather only at a high level. A detailed understanding of the entities and their relations turned out to be a much bigger analytical task than I had expected. I should add that at this stage Claude Code with the Fable model was already available. The main reason was 20 years of history, decisions, and extensions pushed into existing dynamic fields. As a result, the structure of a given field could differ dramatically for different kinds of ads (for example flexible ads) or assets. What's worse, from the data model perspective, the context also affected how the data should be joined or which set of fields should be selected. Neither for LLM agents nor for experienced data engineers was the documentation sufficient, not even close. It required combining knowledge from the documentation, information about what the customer sees/configured in the Meta Ads platform, and how it was reflected in the data model. With all of that, we managed to design and build our internal data model for Meta Ads. One that was actually usable.

The initial difficulties in modeling Meta Ads data weren't the end of the problems in this area. While working on it, it turned out that Meta changes the Meta Ads API contract (for example by removing a few fields) without any warning. There isn't even any information AFTER the fact. On top of that, the documentation is often not updated in this regard either. As a result, we had to monitor the quality of the fields which were critical for our internal model ourselves.

Another "curiosity" was the fact that for our platform to use the Meta Ads API, the app in the Meta Ads portal had to go through a verification process. It turned out that the process is manual! Initially it required a lot of data from us, in particular information about the company itself, where and how it's registered, etc. Then part of the "verification" was done manually and took from a few days up to three weeks! Each additional iteration took at least a few days. From our perspective, with customers already scheduled for integration, having the deployment blocked by the verification process was very frustrating. Maybe we were too optimistic expecting it to take a few days at most. Either way, I didn't expect such a situation in 2026 at one of the biggest tech companies in the world.

Eventually, by necessity, I learned way more about Meta Ads and its data model than I ever wanted to. Funnily enough, somewhere around 2021–2022 I took part in a recruitment process at Meta for a Data Engineer position (which ended prematurely, because the position had been filled before I finished the process). From this perspective, I'm actually glad that nothing came of it. I definitely dodged a bullet...

Reflections

Horizontal product

Even before ConnectyAI prepared its pitch deck[2], we very seriously considered whether to build a horizontal product (covering many areas) or a vertical one (specialized). A vertical product usually gains more favor with investors and is easier to sell. On the other hand, a horizontal product has a bigger market potential, but it's harder to build and sell. Investors only confirmed this view. Ideally, you'd find a vertical product which can be extended horizontally. Unfortunately, that's quite hard even in theory.

At ConnectyAI we decided to go with a horizontal product. Even from today's perspective I think that in itself it wasn't a bad decision. However, considering the size of the initial investment, the length of the runway[3], and the underestimated amount of time needed to build the alpha version of the platform, the odds probably weren't high. Of course, it's easy to say now. Two years ago it wasn't that clear at all.

Product Market Fit

The main goal of commercial products is making money, usually by selling a product or a service to customers. In the product lifecycle, after the vision and building the first version of the product or its prototype, comes the phase where you need to confront what you've built with the actual needs of the market. Often product adoption isn't instant. Users have remarks, or potential customers say that they "would buy this product if [...]". This phase of polishing the product in the context of the market is often called Product Market Fit. During this time the product is iteratively adjusted to the market's needs. In theory it all makes sense. The problem arises when groups of customers have conflicting requirements regarding the product's functionality. Or when a customer says that they would buy the product if it had a given feature, and after it's delivered they still don't buy it. It seems to me that in the PMF phase it's easy to fall into the trap of potential customers influencing the product too much, which might blur the product's vision and its internal integrity. That didn't happen at ConnectyAI, but I witnessed how close it was. That's, of course, another thing which is easy to say and much harder to do. Under the pressure of time and limited financial resources, winning customers by temporarily sacrificing the product's integrity might be necessary. At ConnectyAI I wasn't in a position to decide about it, but I was close enough to understand how hard that task is.

Morale

In startups the dynamics of work in terms of the upcoming tasks is usually very high. The problems you work on can change literally from one day to the next, unlike in large organizations, where plans are often prepared for a quarter or even a year ahead. It's something you need to get used to. It wasn't entirely new to me, though. In consulting the variability of tasks and projects was usually high as well.

At ConnectyAI this high variability often affected the team's morale. In phases of intensive feature development, when the product was growing before our eyes, morale was high. However, when an early customer pulled out of the collaboration or a demo didn't go too well, morale of course went down. That's natural. What in my opinion, in hindsight, could have been done better is consciously working on raising morale in those harder moments. Often it didn't happen, because in such situations everyone had even more work on their plate. Of course, everyone dealt with it somehow. My personal lesson for the future is to try to react earlier in such situations.

Personal cure

For most of my professional career I've had the vision that I'm able to create (design and implement) a product which could be used by other people or companies, and eventually build a company around that product. I still believe that the first part is true, but my time at the startup showed me that the second part is much harder. Sales, business model, marketing, networking, fundraising — these are just a few of the important matters I hadn't thought about in detail before. Working at a startup cured me of the vision that I can relatively easily commercialize a product. Of course, it was never a direct goal of my side projects. But now I know exactly what it involves.

Summary

These two years at ConnectyAI were a very interesting time for me. A very intense time in terms of work, learning, and new professional experiences. A time in which I gained invaluable experience and significantly broadened my perspective on business and product matters. I'd like to end this post by thanking the whole ConnectyAI team for working together, for the support, and for the inspiration. Special thanks to Aisha (CEO) and Piotrek (CTO) for the trust and the opportunity to work at their startup.

Footnotes

  1. pivot — in the startup context, a significant change of the business strategy.
  2. pitch deck — in the startup context, a presentation for potential investors which presents the vision, product, market, and business strategy of the startup.
  3. runway — in the startup context, the amount of time a startup can survive financially at the current rate of spending and revenue. Usually expressed in months.