
        
          
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';


        
          
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };


        
          
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);


        
          
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });


        
          
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();
            
              
            
              type Service = 'web' | 'app' | 'ios';
            
              
            
              export const site = {
            
                brand: 'webklasik',
            
                stack: ['astro', 'typescript', 'scss'],
            
              };
            
              
            
              async function build(project) {
            
                // od návrhu po nasazení
            
                const design = await sketch(project);
            
                const app = await code(design);
            
                return deploy(app);
            
              }
            
              
            
              for (const client of clients) {
            
                await build(client.project);
            
                ship(client, { onTime: true });
            
              }
            
              
            
              // rychlost není náhoda
            
              const score = await lighthouse(url);
            
              if (score.performance < 95) optimize();

Beru nové projekty

Weby · Aplikace · iOS

Weby a aplikace, které dávají smysl vašemu podnikání

Od prvního nákresu po spuštění. Stavím rychlé webové stránky, aplikace šité na míru vašim procesům a mobilní aplikace pro iOS — čistě, moderně a bez zbytečné složitosti.

Poptat projekt Prohlédnout reference

Stanislav Kašika — Tvorba webových stránek a aplikací na míru

Zavolejte mi Odpovídám do 24 hodin

Posunout dolů

Co pro vás udělám

Tři věci, které umím opravdu dobře

Nedělám všechno pro všechny. Soustředím se na to, co má pro vaše podnikání měřitelný přínos.

Webové stránky

Prezentace, které načtou rychle, vypadají dobře na mobilu a najdou je i lidé na Googlu.

Design
Vývoj
SEO

Zjistit více

Aplikace šité na míru

Vnitřní systémy, kalkulačky, rezervace a evidence — přesně podle toho, jak firma funguje.

Aplikace na míru
Databáze
Automatizace

Zjistit více

Mobilní aplikace pro iOS

Aplikace pro iPhone od návrhu obrazovek až po schválení v App Store.

iOS
App Store
UX

Zjistit více

Všechny služby

Kdo za tím stojí

Jeden člověk, celá cesta projektu

Jsem samostatný vývojář a designér. Znamená to, že mluvíte přímo s tím, kdo váš projekt navrhuje i programuje — bez prostředníků, bez ztracených informací a bez čekání na odpověď z druhé strany firmy.

Pracuji v malém počtu projektů souběžně, takže vím, co váš web dělá a proč. Po spuštění se o něj dál starám — od aktualizací po další rozvoj podle toho, jak roste vaše podnikání.

Jasná cena a termín předem, žádné překvapení ve faktuře
Komunikace v lidské řeči, ne v technickém žargonu
Web, který vlastníte vy — bez uzamčení k jednomu dodavateli

Více o službách

Vybrané projekty

Weby a aplikace, které už běží

Průřez tím, co jsem postavil — od prezentací po rozsáhlejší aplikace.

Všechny reference

Web

Prezentace, která z právničiny dělá srozumitelnou službu — bez odstrašujícího žargonu.

Web
Advokacie
Redakční systém

Web

Osobní web, kde je hlavním obsahem důvěra — protože podle ní si klient terapeuta vybírá.

Web
Terapie
Osobní značka

Náhled webu Hive House — glamping se včelami

Web

Web pro apidomek a glamping na Vysočině, kde se spí nad živými včelími úly.

Web
Ubytování
Glamping

Náhled webu Pekárna Pacov — ubytování a komerční prostory

Web

Jeden web pro dvě různé cílové skupiny: firmy hledající ubytování a nájemce prostor.

Web
Ubytování
Pronájem

Aplikace

Kompletní obsluha firemních vozidel — tankování, servis a evidence — v jedné aplikaci pro všechny zaměstnance.

Aplikace na míru
Vozový park
Interní systém

Jak to probíhá

Cesta od nápadu ke spuštění

Konzultace

Sejdeme se online nebo osobně. Zjistím, co potřebujete a co má web reálně přinést.
Návrh

Připravím strukturu a vizuální návrh. Uvidíte, jak bude web vypadat, než začnu programovat.
Vývoj

Naprogramuji web nebo aplikaci. Průběžně vám ukazuji funkční verzi, ne slepé sliby.
Spuštění a péče

Nasadím projekt, doladím SEO a rychlost. Pak se starám o provoz a další rozvoj.