Cybertec PostgreSQL · 2026
How I built Design Ecosystem and centralised everything
Two to three decks a week, every one built by hand. Five months later, nobody needed a designer to make one.
Two to three decks a week, every one built by hand. Five months later, nobody needed a designer to make one.
Cybertec ran two to three internal and client-facing events every week, and each one needed a deck. Every deck started as a blank Google Slides file. Alongside that ran a constant trickle of blog covers and social posts, each one rebuilt separately in Illustrator or Photoshop.
Nothing was templated. Everything depended on a designer being free at the exact moment somebody needed something. When they weren't, work queued behind them, or somebody made do on their own and the output quietly drifted off brand.
Nobody was asking for more designers. They were asking why they couldn't do the repetitive parts themselves.
The pattern that kept surfacing in the graphics team interviewsOne client-ready deck, built by hand in Google Slides.
Every social post and blog cover, started from scratch.
Illustrator, InDesign, Photoshop and Slides, sharing no source.
I didn't open Figma for the first few weeks. The obvious answer was "make templates", and I wanted to know why that hadn't already fixed it before I built anything on top of that assumption.
Not on creative decisions. On rebuilding the same layouts, re-typing the same content, and chasing brand details across files.
The content team knew what they wanted to say. They just couldn't make it look right, and had no interest in learning a design tool to do it.
Static templates existed and got ignored. They went stale the moment the brand shifted, and nobody trusted them enough to use one unsupervised.
My first instinct was a template gallery: a tidy library the content team could browse and pick from. Sitting with them killed that idea. Choosing a layout was the part they least wanted to do, because choosing meant owning whether it looked right.
So the model inverted. The content team brings words. The system picks the layout. A designer, once, decides what the system is allowed to pick from. That single reversal is why it got used instead of ignored like every static template before it.
The principle everything after this had to hold up.
Small design team, no product manager on this, no engineer until the end. So the work ran from finding the problem all the way to writing the spec that let somebody else finish it.
Mapped every asset scattered across four tools and rebuilt them as one structured Figma system. That file became the company's source of truth, and everything downstream reads from it.
Instead of static mockups, I put working prototypes in front of the graphics team within days. Being able to click through a wrong idea quickly is what killed the template gallery early, before it cost anything.
Took the validated flow and built the real thing, wiring Figma in over MCP so a pulled frame keeps its fonts, colours and layout exactly as designed.
Wrote the ruleset a developer needed: colour by role, type rules, the spacing grid, accessibility floors, export specs. Anything undecided was marked undecided rather than guessed at.
The whole design rests on separating these two people completely. A designer sets the system up, once. The content team runs it, daily, and never sees a design decision.
Once per template, then never again
Every day, with no design input
I wireframed in plain boxes first, deliberately unstyled, so every conversation stayed on the flow instead of the colours. By the time it was worth making anything look finished, the structure and the vocabulary were already settled.
Testing the wireframes settled the vocabulary before a line of production code existed. The unit became Add a Slide, with a Template promoted to mean the set those slides belong to, which matched how the team already talked about their decks.
The final step became Review and export, leading with the review, because that screen's real job is the last look before anything leaves the building.
Cheap to redraw a grey box. Expensive to rename a concept people have already learned.
Why the rough stage stayed rough for as long as it didThis was the design problem underneath the whole project, and the part I spent longest getting right.
Every deck needs a designer's sign-off again. The queue comes straight back and the tool has solved nothing.
Brand consistency slips within weeks. Which is precisely what happened to the static templates nobody trusted.
A designer pins the brand-critical slides to a position. Those always appear, always there, and cannot be moved or removed. Everything between them fills in automatically from whatever content arrives. The edges stay locked, the middle stays free, and nobody has to negotiate per deck.
Deliberately unremarkable. Two ways in, one screen to review, no design decisions anywhere in the path.
Two entry points, because research turned up two genuinely different working styles. Some people arrive with a finished document. Others think in sections and want to shape the order themselves.
What both share is the absence of a design choice. There is no template picker on this screen. That decision was already made upstream by someone whose job it is.
No design decisions required from this user.
The line I kept at the bottom of every content team wireframe, as a constraint to design againstThe review screen is the only place editing happens. Every slide in order down one side, the selected slide's text fields on the other. Fixed slides show a lock and no edit affordance. Everything else can be reordered or reworded.
Then it exports. PPTX matters most: it stays editable in PowerPoint, which is what makes the output a real deliverable instead of something trapped inside an internal tool.
Not a Figma file and a conversation. A working prototype, plus a ruleset where every rule is specific enough to be checked automatically.
Colour by role, not by vibe. Type rules including when the highlight face is allowed. An eight pixel grid with its one documented exception. Accessibility floors, export specs, file naming.
Their job became fixing bugs and hardening it, not reverse-engineering intent from static mockups.
What used to be a request became something people finished themselves.
On these numbers: they are my own read from watching request volume after rollout, not a formal audited study. The structural change is the part I would defend without hesitation.
The build was the fast part. AI-assisted prototyping meant I could put a working flow in front of people in days rather than sprints. That changed how quickly I could be wrong and recover from it.
The slow part was earlier, and I would give it even more room next time: understanding what a team had stopped bothering to ask for. The template gallery I nearly built would have shipped, looked fine, and been ignored, exactly like everything before it.
Still unfinished: real permissions instead of a role switch, a no-code path for admins to add templates without a developer, and true client-side PPTX generation. All sequenced out on purpose. None of them were needed to prove the idea.